{
  "D:bin",
  "{\
  \"F:archiver\",\
  \"\\\"print(\\\\\\\"Debian CC Archiver v0.1 by 1Ridav\\\\\\\")\\\\\\\
tArgs = {...}\\\\\\\
local function getPath(input)\\\\\\\
if string.sub(input, 1, 1)==\\\\\\\"/\\\\\\\" then path=input else\\\\\\\
path=(\\\\\\\"/\\\\\\\" .. shell.dir() .. \\\\\\\"/\\\\\\\" .. input) end\\\\\\\
return path\\\\\\\
end\\\\\\\
if tArgs[2] then\\\\\\\
tArgs[2]=getPath(tArgs[2])\\\\\\\
end\\\\\\\
\\\\\\\
local FFormat = \\\\\\\".arch\\\\\\\"\\\\\\\
local nFile, nDir, size = 0, 0\\\\\\\
\\\\\\\
if #tArgs < 3 then \\\\\\\
  print(\\\\\\\"Usage:\\\\\\\"\\\\\\\
    ..\\\\\\\"\\\\\\\\narchive zip <DIR> <ZIPname> [DIRtoSkip] [DIRtoSkip]\\\\\\\"\\\\\\\
    ..\\\\\\\"\\\\\\\\narchive unzip <ZIPname> <DIR>\\\\\\\")\\\\\\\
end\\\\\\\
\\\\\\\
local function fopen(path, mode)\\\\\\\
  local f = fs.open(path, mode)\\\\\\\
  if not f then \\\\\\\
    print(\\\\\\\"ERROR: Could not open \\\\\\\"..path..\\\\\\\" with mode \\\\\\\\\\\\\\\"\\\\\\\"..mode..\\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\")\\\\\\\
    exit()\\\\\\\
  end\\\\\\\
  return f\\\\\\\
end\\\\\\\
\\\\\\\
local function skip(df)\\\\\\\
  for i = 3, #tArgs do\\\\\\\
    if tArgs[i] == fs.getName(df) then\\\\\\\
      return true\\\\\\\
    end\\\\\\\
  end\\\\\\\
  for i = 4, #tArgs do\\\\\\\
    if tArgs[i] == fs.getName(df) then\\\\\\\
      return true\\\\\\\
    end\\\\\\\
  end\\\\\\\
  return false\\\\\\\
end\\\\\\\
\\\\\\\
local function zip(file)\\\\\\\
  print(\\\\\\\"zipping: \\\\\\\".. file)\\\\\\\
  local f = fopen(file, \\\\\\\"r\\\\\\\")\\\\\\\
  local z = textutils.serialize(f.readAll())\\\\\\\
  f.close()\\\\\\\
  return z\\\\\\\
end\\\\\\\
\\\\\\\
local function ZIP(path)\\\\\\\
  local list = fs.list(path)\\\\\\\
  local array = {}\\\\\\\
  local t, name, d = 0, \\\\\\\"\\\\\\\", 0\\\\\\\
  \\\\\\\
  for i = 2, #list * 2, 2 do\\\\\\\
    t = i/2\\\\\\\
    local tpath = path..\\\\\\\"/\\\\\\\"..list[t]\\\\\\\
    if fs.isDir(tpath) then\\\\\\\
      if not skip(tpath) then\\\\\\\
        name = \\\\\\\"D:\\\\\\\"..list[t]\\\\\\\
        array[i] = ZIP(tpath)\\\\\\\
        nDir = nDir + 1\\\\\\\
      end\\\\\\\
    else\\\\\\\
      name = \\\\\\\"F:\\\\\\\"..list[t]\\\\\\\
      array[i] = zip(tpath)\\\\\\\
      nFile = nFile + 1\\\\\\\
    end\\\\\\\
    array[i - 1] = name\\\\\\\
  end\\\\\\\
  \\\\\\\
  return textutils.serialize(array)\\\\\\\
end\\\\\\\
\\\\\\\
local function unzip(text, path)\\\\\\\
  print(\\\\\\\"unzipping: \\\\\\\"..path)\\\\\\\
  local f = fopen(path, \\\\\\\"w\\\\\\\")\\\\\\\
  f.write(textutils.unserialize(text))\\\\\\\
  f.close()\\\\\\\
end\\\\\\\
\\\\\\\
local function UNZIP(text, path)\\\\\\\
  local array = textutils.unserialize(text)\\\\\\\
  local unz, dp\\\\\\\
  local d = 0\\\\\\\
  for i = 2, #array, 2 do\\\\\\\
    if string.sub(array[i-1], 1, 1) == \\\\\\\"D\\\\\\\" then\\\\\\\
      dp = string.sub(array[i-1], 3, #array[i-1])\\\\\\\
      fs.makeDir(path..\\\\\\\"/\\\\\\\"..dp)\\\\\\\
      UNZIP(array[i], path..\\\\\\\"/\\\\\\\"..dp)\\\\\\\
      nDir = nDir + 1\\\\\\\
    elseif string.sub(array[i-1], 1, 1) == \\\\\\\"F\\\\\\\" then\\\\\\\
      local p = string.sub(array[i-1], 3, #array[i-1])\\\\\\\
      unzip(array[i], path..\\\\\\\"/\\\\\\\"..p)\\\\\\\
      nFile = nFile + 1\\\\\\\
    end\\\\\\\
  end\\\\\\\
end\\\\\\\
\\\\\\\
local function result()\\\\\\\
  print(\\\\\\\"\\\\\\\\nDone\\\\\\\"\\\\\\\
    ,\\\\\\\"\\\\\\\\n   size: \\\\\\\"\\\\\\\
    ,size, \\\\\\\" B   \\\\\\\"\\\\\\\
    ,math.floor(size/1024), \\\\\\\" KB\\\\\\\"\\\\\\\
    ,\\\\\\\"\\\\\\\\n   Files:   \\\\\\\", nFile\\\\\\\
    ,\\\\\\\"\\\\\\\\n   Folders: \\\\\\\", nDir\\\\\\\
  )\\\\\\\
end\\\\\\\
\\\\\\\
if tArgs[1] == \\\\\\\"zip\\\\\\\" then\\\\\\\
  if fs.exists(tArgs[2]) and fs.isDir(tArgs[2]) then\\\\\\\
    local zipped = ZIP(shell.resolve(tArgs[2]))\\\\\\\
    local f = fs.open(tArgs[3]..FFormat, \\\\\\\"w\\\\\\\")\\\\\\\
    f.write(zipped)\\\\\\\
    f.close()\\\\\\\
    zipped = nil\\\\\\\
    size = fs.getSize(tArgs[3]..FFormat)\\\\\\\
    result()   \\\\\\\
  end\\\\\\\
  \\\\\\\
elseif tArgs[1] == \\\\\\\"unzip\\\\\\\" then\\\\\\\
    local f = fopen(tArgs[2], \\\\\\\"r\\\\\\\")\\\\\\\
    if not fs.exists(tArgs[3]) then \\\\\\\
      fs.makeDir(tArgs[3]) \\\\\\\
    end\\\\\\\
    UNZIP(f.readAll(), tArgs[3])\\\\\\\
    size = fs.getSize(tArgs[2])\\\\\\\
    result()\\\\\\\
end\\\"\",\
  \"F:cat\",\
  \"\\\"local tArgs = {...}\\\\\\\
\\\\\\\
if #tArgs >= 1 then\\\\\\\
 path = shell.resolve(tArgs[1])\\\\\\\
 if fs.isReadOnly(path) and not security.getSU() then\\\\\\\
  -- prevent users from seeing unauthorized code\\\\\\\
  -- they should only be able to see their own files and ones in /var/log\\\\\\\
  exception.throw(\\\\\\\"SecurityException\\\\\\\", path)\\\\\\\
  return\\\\\\\
 end\\\\\\\
 if not fs.exists(path) or fs.isDir(path) then\\\\\\\
  gui.printAppInfo(\\\\\\\"cat\\\\\\\", \\\\\\\"file does not exist\\\\\\\")\\\\\\\
 else\\\\\\\
  textutils.pagedPrint(kernel.printFile(path))\\\\\\\
 end\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"cat\\\\\\\", \\\\\\\"filename not specified\\\\\\\")\\\\\\\
end\\\\\\\
\\\"\",\
  \"F:convert\",\
  \"\\\"local args = {...}\\\\\\\
\\\\\\\
local function checksys(txt)\\\\\\\
 if txt == \\\\\\\"kernel\\\\\\\" or txt == \\\\\\\"gui\\\\\\\" or txt == \\\\\\\"app\\\\\\\" or txt == \\\\\\\"log\\\\\\\" or txt == \\\\\\\"config\\\\\\\" or txt == \\\\\\\"manual\\\\\\\" or txt == \\\\\\\"search\\\\\\\" or txt == \\\\\\\"tpm\\\\\\\" or txt == \\\\\\\"exception\\\\\\\" or string.find(txt, \\\\\\\"boot/\\\\\\\") or string.find(txt, \\\\\\\"system/\\\\\\\") or string.find(txt, \\\\\\\"/startup\\\\\\\") then\\\\\\\
  --gui.printAppWarning(\\\\\\\"kernel\\\\\\\", \\\\\\\"attempt to perform restricted operations\\\\\\\")\\\\\\\
  return true\\\\\\\
 end\\\\\\\
end\\\\\\\
\\\\\\\
if #args < 1 or not fs.exists(shell.resolveProgram(args[1])) or fs.isDir(shell.resolve(args[1])) then\\\\\\\
 gui.printAppInfo(\\\\\\\"config\\\\\\\", \\\\\\\"file not specified\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if not checksys(shell.resolveProgram(args[1])) then\\\\\\\
 if os.loadAPI(shell.resolveProgram(args[1])) then\\\\\\\
  config.save(_G[args[1]], textutils.serialize(args[1]))\\\\\\\
  os.unloadAPI(args[1])\\\\\\\
  gui.printAppSuccess(\\\\\\\"config\\\\\\\", \\\\\\\"conversion succeeded\\\\\\\")\\\\\\\
 end\\\\\\\
else\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:credits\",\
  \"\\\"shell.run(\\\\\\\"/bin/man credits\\\\\\\")\\\"\",\
  \"F:df\",\
  \"\\\"local tArgs = {...}\\\\\\\
local sz = fs.getSize(shell.dir())\\\\\\\
local fspc = fs.getFreeSpace(shell.dir())\\\\\\\
\\\\\\\
gui.printAppInfo(\\\\\\\"type\\\\\\\", fs.getDrive(shell.dir()))\\\\\\\
if search.findValue(tArgs, \\\\\\\"-sB\\\\\\\") then\\\\\\\
 gui.printAppInfo(\\\\\\\"size\\\\\\\", tostring(sz)..\\\\\\\" B\\\\\\\")\\\\\\\
 gui.printAppInfo(\\\\\\\"free space\\\\\\\", tostring(fspc)..\\\\\\\" B\\\\\\\")\\\\\\\
elseif search.findValue(tArgs, \\\\\\\"-sKB\\\\\\\") then\\\\\\\
 gui.printAppInfo(\\\\\\\"size\\\\\\\", tostring(sz/1024)..\\\\\\\" KB\\\\\\\")\\\\\\\
 gui.printAppInfo(\\\\\\\"free space\\\\\\\", tostring(fspc/1024)..\\\\\\\" KB\\\\\\\")\\\\\\\
end\\\\\\\
\\\"\",\
  \"F:edit\",\
  \"\\\"-- Get file to edit\\\\\\\
local tArgs = { ... }\\\\\\\
if #tArgs == 0 then\\\\\\\
	print( \\\\\\\"Usage: edit <path>\\\\\\\" )\\\\\\\
	return\\\\\\\
end\\\\\\\
\\\\\\\
-- Error checking\\\\\\\
local sPath = shell.resolve( tArgs[1] )\\\\\\\
local bReadOnly = fs.isReadOnly( sPath )\\\\\\\
if fs.exists( sPath ) and fs.isDir( sPath ) then\\\\\\\
	print( \\\\\\\"Cannot edit a directory.\\\\\\\" )\\\\\\\
	return\\\\\\\
end\\\\\\\
\\\\\\\
if bReadOnly and not security.getSU() then\\\\\\\
 -- prevent users from seeing unauthorized code\\\\\\\
 -- they should only be able to see their own files and ones in /var/log\\\\\\\
 exception.throw(\\\\\\\"SecurityException\\\\\\\", sPath)\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
local x,y = 1,1\\\\\\\
local w,h = term.getSize()\\\\\\\
local scrollX, scrollY = 0,0\\\\\\\
\\\\\\\
local tLines = {}\\\\\\\
local bRunning = true\\\\\\\
\\\\\\\
-- Colours\\\\\\\
local highlightColour, keywordColour, commentColour, textColour, bgColour\\\\\\\
if term.isColour() then\\\\\\\
	bgColour = colours.black\\\\\\\
	textColour = colours.white\\\\\\\
	highlightColour = colours.yellow\\\\\\\
	keywordColour = colours.yellow\\\\\\\
	commentColour = colours.green\\\\\\\
	stringColour = colours.red\\\\\\\
else\\\\\\\
	bgColour = colours.black\\\\\\\
	textColour = colours.white\\\\\\\
	highlightColour = colours.white\\\\\\\
	keywordColour = colours.white\\\\\\\
	commentColour = colours.white\\\\\\\
	stringColour = colours.white\\\\\\\
end\\\\\\\
\\\\\\\
-- Menus\\\\\\\
local bMenu = false\\\\\\\
local nMenuItem = 1\\\\\\\
local tMenuItems = {}\\\\\\\
if not bReadOnly then\\\\\\\
    table.insert( tMenuItems, \\\\\\\"Save\\\\\\\" )\\\\\\\
end\\\\\\\
if shell.openTab then\\\\\\\
    table.insert( tMenuItems, \\\\\\\"Run\\\\\\\" )\\\\\\\
end\\\\\\\
if peripheral.find( \\\\\\\"printer\\\\\\\" ) then\\\\\\\
    table.insert( tMenuItems, \\\\\\\"Print\\\\\\\" )\\\\\\\
end\\\\\\\
table.insert( tMenuItems, \\\\\\\"Exit\\\\\\\" )\\\\\\\
\\\\\\\
local sStatus = \\\\\\\"Press Ctrl to access menu\\\\\\\"\\\\\\\
if string.len( sStatus ) > w - 5 then\\\\\\\
    sStatus = \\\\\\\"Press Ctrl for menu\\\\\\\"\\\\\\\
end\\\\\\\
\\\\\\\
local function load( _sPath )\\\\\\\
	tLines = {}\\\\\\\
	if fs.exists( _sPath ) then\\\\\\\
		local file = io.open( _sPath, \\\\\\\"r\\\\\\\" )\\\\\\\
		local sLine = file:read()\\\\\\\
		while sLine do\\\\\\\
			table.insert( tLines, sLine )\\\\\\\
			sLine = file:read()\\\\\\\
		end\\\\\\\
		file:close()\\\\\\\
	end\\\\\\\
	\\\\\\\
	if #tLines == 0 then\\\\\\\
		table.insert( tLines, \\\\\\\"\\\\\\\" )\\\\\\\
	end\\\\\\\
end\\\\\\\
\\\\\\\
local function save( _sPath )\\\\\\\
	-- Create intervening folder\\\\\\\
	local sDir = _sPath:sub(1, _sPath:len() - fs.getName(_sPath):len() )\\\\\\\
	if not fs.exists( sDir ) then\\\\\\\
		fs.makeDir( sDir )\\\\\\\
	end\\\\\\\
\\\\\\\
	-- Save\\\\\\\
	local file = nil\\\\\\\
	local function innerSave()\\\\\\\
		file = fs.open( _sPath, \\\\\\\"w\\\\\\\" )\\\\\\\
		if file then\\\\\\\
			for n, sLine in ipairs( tLines ) do\\\\\\\
				file.write( sLine .. \\\\\\\"\\\\\\\\n\\\\\\\" )\\\\\\\
			end\\\\\\\
		else\\\\\\\
			error( \\\\\\\"Failed to open \\\\\\\".._sPath )\\\\\\\
		end\\\\\\\
	end\\\\\\\
	\\\\\\\
	local ok, err = pcall( innerSave )\\\\\\\
	if file then \\\\\\\
		file.close()\\\\\\\
	end\\\\\\\
	return ok, err\\\\\\\
end\\\\\\\
\\\\\\\
local tKeywords = {\\\\\\\
	[\\\\\\\"and\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"break\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"do\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"else\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"elseif\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"end\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"false\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"for\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"function\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"if\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"in\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"local\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"nil\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"not\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"or\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"repeat\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"return\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"then\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"true\\\\\\\"] = true,\\\\\\\
	[\\\\\\\"until\\\\\\\"]= true,\\\\\\\
	[\\\\\\\"while\\\\\\\"] = true,\\\\\\\
}\\\\\\\
\\\\\\\
local function tryWrite( sLine, regex, colour )\\\\\\\
	local match = string.match( sLine, regex )\\\\\\\
	if match then\\\\\\\
		if type(colour) == \\\\\\\"number\\\\\\\" then\\\\\\\
			term.setTextColour( colour )\\\\\\\
		else\\\\\\\
			term.setTextColour( colour(match) )\\\\\\\
		end\\\\\\\
		term.write( match )\\\\\\\
		term.setTextColour( textColour )\\\\\\\
		return string.sub( sLine, string.len(match) + 1 )\\\\\\\
	end\\\\\\\
	return nil\\\\\\\
end\\\\\\\
\\\\\\\
local function writeHighlighted( sLine )\\\\\\\
	while string.len(sLine) > 0 do	\\\\\\\
		sLine = \\\\\\\
			tryWrite( sLine, \\\\\\\"^%-%-%[%[.-%]%]\\\\\\\", commentColour ) or\\\\\\\
			tryWrite( sLine, \\\\\\\"^%-%-.*\\\\\\\", commentColour ) or\\\\\\\
			tryWrite( sLine, \\\\\\\"^\\\\\\\\\\\\\\\".-[^\\\\\\\\\\\\\\\\]\\\\\\\\\\\\\\\"\\\\\\\", stringColour ) or\\\\\\\
			tryWrite( sLine, \\\\\\\"^\\\\\\\\'.-[^\\\\\\\\\\\\\\\\]\\\\\\\\'\\\\\\\", stringColour ) or\\\\\\\
			tryWrite( sLine, \\\\\\\"^%[%[.-%]%]\\\\\\\", stringColour ) or\\\\\\\
			tryWrite( sLine, \\\\\\\"^[%w_]+\\\\\\\", function( match )\\\\\\\
				if tKeywords[ match ] then\\\\\\\
					return keywordColour\\\\\\\
				end\\\\\\\
				return textColour\\\\\\\
			end ) or\\\\\\\
			tryWrite( sLine, \\\\\\\"^[^%w_]\\\\\\\", textColour )\\\\\\\
	end\\\\\\\
end\\\\\\\
\\\\\\\
local tCompletions\\\\\\\
local nCompletion\\\\\\\
\\\\\\\
local tCompleteEnv = _ENV\\\\\\\
local function complete( sLine )\\\\\\\
    local nStartPos = string.find( sLine, \\\\\\\"[a-zA-Z0-9_%.]+$\\\\\\\" )\\\\\\\
    if nStartPos then\\\\\\\
        sLine = string.sub( sLine, nStartPos )\\\\\\\
    end\\\\\\\
    if #sLine > 0 then\\\\\\\
        return textutils.complete( sLine, tCompleteEnv )\\\\\\\
    end\\\\\\\
    return nil\\\\\\\
end\\\\\\\
\\\\\\\
local function recomplete()\\\\\\\
    local sLine = tLines[y]\\\\\\\
    if not bMenu and not bReadOnly and x == string.len(sLine) + 1 then\\\\\\\
        tCompletions = complete( sLine )\\\\\\\
        if tCompletions and #tCompletions > 0 then\\\\\\\
            nCompletion = 1\\\\\\\
        else\\\\\\\
            nCompletion = nil\\\\\\\
        end\\\\\\\
    else\\\\\\\
        tCompletions = nil\\\\\\\
        nCompletion = nil\\\\\\\
    end\\\\\\\
end\\\\\\\
\\\\\\\
local function writeCompletion( sLine )\\\\\\\
    if nCompletion then\\\\\\\
        local sCompletion = tCompletions[ nCompletion ]\\\\\\\
        term.setTextColor( colours.white )\\\\\\\
        term.setBackgroundColor( colours.grey )\\\\\\\
        term.write( sCompletion )\\\\\\\
        term.setTextColor( textColour )\\\\\\\
        term.setBackgroundColor( bgColour )\\\\\\\
    end\\\\\\\
end\\\\\\\
\\\\\\\
local function redrawText()\\\\\\\
    local cursorX, cursorY = x, y\\\\\\\
	for y=1,h-1 do\\\\\\\
		term.setCursorPos( 1 - scrollX, y )\\\\\\\
		term.clearLine()\\\\\\\
\\\\\\\
		local sLine = tLines[ y + scrollY ]\\\\\\\
		if sLine ~= nil then\\\\\\\
			writeHighlighted( sLine )\\\\\\\
            if cursorY == y and cursorX == #sLine + 1 then\\\\\\\
                writeCompletion()\\\\\\\
            end\\\\\\\
		end\\\\\\\
	end\\\\\\\
	term.setCursorPos( x - scrollX, y - scrollY )\\\\\\\
end\\\\\\\
\\\\\\\
local function redrawLine(_nY)\\\\\\\
	local sLine = tLines[_nY]\\\\\\\
	if sLine then\\\\\\\
        term.setCursorPos( 1 - scrollX, _nY - scrollY )\\\\\\\
        term.clearLine()\\\\\\\
        writeHighlighted( sLine )\\\\\\\
        if _nY == y and x == #sLine + 1 then\\\\\\\
            writeCompletion()\\\\\\\
        end\\\\\\\
        term.setCursorPos( x - scrollX, _nY - scrollY )\\\\\\\
    end\\\\\\\
end\\\\\\\
\\\\\\\
local function redrawMenu()\\\\\\\
    -- Clear line\\\\\\\
    term.setCursorPos( 1, h )\\\\\\\
	term.clearLine()\\\\\\\
\\\\\\\
    -- Draw line numbers\\\\\\\
    term.setCursorPos( w - string.len( \\\\\\\"Ln \\\\\\\"..y ) + 1, h )\\\\\\\
    term.setTextColour( highlightColour )\\\\\\\
    term.write( \\\\\\\"Ln \\\\\\\" )\\\\\\\
    term.setTextColour( textColour )\\\\\\\
    term.write( y )\\\\\\\
\\\\\\\
    term.setCursorPos( 1, h )\\\\\\\
	if bMenu then\\\\\\\
        -- Draw menu\\\\\\\
		term.setTextColour( textColour )\\\\\\\
		for nItem,sItem in pairs( tMenuItems ) do\\\\\\\
			if nItem == nMenuItem then\\\\\\\
				term.setTextColour( highlightColour )\\\\\\\
				term.write( \\\\\\\"[\\\\\\\" )\\\\\\\
				term.setTextColour( textColour )\\\\\\\
				term.write( sItem )\\\\\\\
				term.setTextColour( highlightColour )\\\\\\\
				term.write( \\\\\\\"]\\\\\\\" )\\\\\\\
        		term.setTextColour( textColour )\\\\\\\
			else\\\\\\\
				term.write( \\\\\\\" \\\\\\\"..sItem..\\\\\\\" \\\\\\\" )\\\\\\\
			end\\\\\\\
		end\\\\\\\
    else\\\\\\\
        -- Draw status\\\\\\\
        term.setTextColour( highlightColour )\\\\\\\
        term.write( sStatus )\\\\\\\
        term.setTextColour( textColour )\\\\\\\
    end\\\\\\\
\\\\\\\
	-- Reset cursor\\\\\\\
	term.setCursorPos( x - scrollX, y - scrollY )\\\\\\\
end\\\\\\\
\\\\\\\
local tMenuFuncs = { \\\\\\\
	Save = function()\\\\\\\
		if bReadOnly then\\\\\\\
			sStatus = \\\\\\\"Access denied\\\\\\\"\\\\\\\
		else\\\\\\\
			local ok, err = save( sPath )\\\\\\\
			if ok then\\\\\\\
				sStatus=\\\\\\\"Saved to \\\\\\\"..sPath\\\\\\\
			else\\\\\\\
				sStatus=\\\\\\\"Error saving to \\\\\\\"..sPath\\\\\\\
			end\\\\\\\
		end\\\\\\\
		redrawMenu()\\\\\\\
	end,\\\\\\\
	Print = function()\\\\\\\
		local printer = peripheral.find( \\\\\\\"printer\\\\\\\" )\\\\\\\
		if not printer then\\\\\\\
			sStatus = \\\\\\\"No printer attached\\\\\\\"\\\\\\\
			return\\\\\\\
		end\\\\\\\
\\\\\\\
		local nPage = 0\\\\\\\
		local sName = fs.getName( sPath )\\\\\\\
		if printer.getInkLevel() < 1 then\\\\\\\
			sStatus = \\\\\\\"Printer out of ink\\\\\\\"\\\\\\\
			return\\\\\\\
		elseif printer.getPaperLevel() < 1 then\\\\\\\
			sStatus = \\\\\\\"Printer out of paper\\\\\\\"\\\\\\\
			return\\\\\\\
		end\\\\\\\
\\\\\\\
		local screenTerminal = term.current()\\\\\\\
		local printerTerminal = {\\\\\\\
			getCursorPos = printer.getCursorPos,\\\\\\\
			setCursorPos = printer.setCursorPos,\\\\\\\
			getSize = printer.getPageSize,\\\\\\\
			write = printer.write,\\\\\\\
		}\\\\\\\
		printerTerminal.scroll = function()\\\\\\\
			if nPage == 1 then\\\\\\\
				printer.setPageTitle( sName..\\\\\\\" (page \\\\\\\"..nPage..\\\\\\\")\\\\\\\" )			\\\\\\\
			end\\\\\\\
			\\\\\\\
			while not printer.newPage()	do\\\\\\\
				if printer.getInkLevel() < 1 then\\\\\\\
					sStatus = \\\\\\\"Printer out of ink, please refill\\\\\\\"\\\\\\\
				elseif printer.getPaperLevel() < 1 then\\\\\\\
					sStatus = \\\\\\\"Printer out of paper, please refill\\\\\\\"\\\\\\\
				else\\\\\\\
					sStatus = \\\\\\\"Printer output tray full, please empty\\\\\\\"\\\\\\\
				end\\\\\\\
	\\\\\\\
				term.redirect( screenTerminal )\\\\\\\
				redrawMenu()\\\\\\\
				term.redirect( printerTerminal )\\\\\\\
				\\\\\\\
				local timer = os.startTimer(0.5)\\\\\\\
				sleep(0.5)\\\\\\\
			end\\\\\\\
\\\\\\\
			nPage = nPage + 1\\\\\\\
			if nPage == 1 then\\\\\\\
				printer.setPageTitle( sName )\\\\\\\
			else\\\\\\\
				printer.setPageTitle( sName..\\\\\\\" (page \\\\\\\"..nPage..\\\\\\\")\\\\\\\" )\\\\\\\
			end\\\\\\\
		end\\\\\\\
		\\\\\\\
		bMenu = false\\\\\\\
		term.redirect( printerTerminal )\\\\\\\
		local ok, error = pcall( function()\\\\\\\
			term.scroll()\\\\\\\
			for n, sLine in ipairs( tLines ) do\\\\\\\
				print( sLine )\\\\\\\
			end\\\\\\\
		end )\\\\\\\
        term.redirect( screenTerminal )\\\\\\\
		if not ok then\\\\\\\
			print( error )\\\\\\\
		end\\\\\\\
		\\\\\\\
		while not printer.endPage() do\\\\\\\
			sStatus = \\\\\\\"Printer output tray full, please empty\\\\\\\"\\\\\\\
			redrawMenu()\\\\\\\
			sleep( 0.5 )\\\\\\\
		end\\\\\\\
		bMenu = true\\\\\\\
			\\\\\\\
		if nPage > 1 then\\\\\\\
			sStatus = \\\\\\\"Printed \\\\\\\"..nPage..\\\\\\\" Pages\\\\\\\"\\\\\\\
		else\\\\\\\
			sStatus = \\\\\\\"Printed 1 Page\\\\\\\"\\\\\\\
		end\\\\\\\
		redrawMenu()\\\\\\\
	end,\\\\\\\
	Exit = function()\\\\\\\
		bRunning = false\\\\\\\
	end,\\\\\\\
	Run = function()\\\\\\\
	    local sTempPath = \\\\\\\"/.temp\\\\\\\"\\\\\\\
        local ok, err = save( sTempPath )\\\\\\\
        if ok then\\\\\\\
            local nTask = shell.openTab( sTempPath )\\\\\\\
            if nTask then\\\\\\\
                shell.switchTab( nTask )\\\\\\\
            else\\\\\\\
                sStatus=\\\\\\\"Error starting Task\\\\\\\"\\\\\\\
            end\\\\\\\
            fs.delete( sTempPath )\\\\\\\
        else\\\\\\\
            sStatus=\\\\\\\"Error saving to \\\\\\\"..sTempPath\\\\\\\
        end\\\\\\\
		redrawMenu()\\\\\\\
    end\\\\\\\
}\\\\\\\
\\\\\\\
local function doMenuItem( _n )\\\\\\\
	tMenuFuncs[tMenuItems[_n]]()\\\\\\\
	if bMenu then\\\\\\\
		bMenu = false\\\\\\\
		term.setCursorBlink( true )\\\\\\\
	end\\\\\\\
	redrawMenu()\\\\\\\
end\\\\\\\
\\\\\\\
local function setCursor( newX, newY )\\\\\\\
    local oldX, oldY = x, y\\\\\\\
    x, y = newX, newY\\\\\\\
	local screenX = x - scrollX\\\\\\\
	local screenY = y - scrollY\\\\\\\
	\\\\\\\
	local bRedraw = false\\\\\\\
	if screenX < 1 then\\\\\\\
		scrollX = x - 1\\\\\\\
		screenX = 1\\\\\\\
		bRedraw = true\\\\\\\
	elseif screenX > w then\\\\\\\
		scrollX = x - w\\\\\\\
		screenX = w\\\\\\\
		bRedraw = true\\\\\\\
	end\\\\\\\
	\\\\\\\
	if screenY < 1 then\\\\\\\
		scrollY = y - 1\\\\\\\
		screenY = 1\\\\\\\
		bRedraw = true\\\\\\\
	elseif screenY > h-1 then\\\\\\\
		scrollY = y - (h-1)\\\\\\\
		screenY = h-1\\\\\\\
		bRedraw = true\\\\\\\
	end\\\\\\\
\\\\\\\
	recomplete()\\\\\\\
	if bRedraw then\\\\\\\
		redrawText()\\\\\\\
	elseif y ~= oldY then\\\\\\\
	    redrawLine( oldY )\\\\\\\
	    redrawLine( y )\\\\\\\
	else\\\\\\\
	    redrawLine( y )\\\\\\\
	end\\\\\\\
	term.setCursorPos( screenX, screenY )\\\\\\\
\\\\\\\
	redrawMenu()\\\\\\\
end\\\\\\\
\\\\\\\
-- Actual program functionality begins\\\\\\\
load(sPath)\\\\\\\
\\\\\\\
term.setBackgroundColour( bgColour )\\\\\\\
term.clear()\\\\\\\
term.setCursorPos(x,y)\\\\\\\
term.setCursorBlink( true )\\\\\\\
\\\\\\\
recomplete()\\\\\\\
redrawText()\\\\\\\
redrawMenu()\\\\\\\
\\\\\\\
local function acceptCompletion()\\\\\\\
    if nCompletion then\\\\\\\
        -- Find the common prefix of all the other suggestions which start with the same letter as the current one\\\\\\\
        local sCompletion = tCompletions[ nCompletion ]\\\\\\\
        local sFirstLetter = string.sub( sCompletion, 1, 1 )\\\\\\\
        local sCommonPrefix = sCompletion\\\\\\\
        for n=1,#tCompletions do\\\\\\\
            local sResult = tCompletions[n]\\\\\\\
            if n ~= nCompletion and string.find( sResult, sFirstLetter, 1, true ) == 1 then\\\\\\\
                while #sCommonPrefix > 1 do\\\\\\\
                    if string.find( sResult, sCommonPrefix, 1, true ) == 1 then\\\\\\\
                        break\\\\\\\
                    else\\\\\\\
                        sCommonPrefix = string.sub( sCommonPrefix, 1, #sCommonPrefix - 1 )\\\\\\\
                    end\\\\\\\
                end\\\\\\\
            end\\\\\\\
        end\\\\\\\
\\\\\\\
        -- Append this string\\\\\\\
        tLines[y] = tLines[y] .. sCommonPrefix\\\\\\\
        setCursor( x + string.len( sCommonPrefix ), y )\\\\\\\
    end\\\\\\\
end\\\\\\\
\\\\\\\
-- Handle input\\\\\\\
while bRunning do\\\\\\\
	local sEvent, param, param2, param3 = os.pullEvent()\\\\\\\
	if sEvent == \\\\\\\"key\\\\\\\" then\\\\\\\
	    local oldX, oldY = x, y\\\\\\\
		if param == keys.up then\\\\\\\
			-- Up\\\\\\\
			if not bMenu then\\\\\\\
			    if nCompletion then\\\\\\\
			        -- Cycle completions\\\\\\\
                    nCompletion = nCompletion - 1\\\\\\\
                    if nCompletion < 1 then\\\\\\\
                        nCompletion = #tCompletions\\\\\\\
                    end\\\\\\\
                    redrawLine(y)\\\\\\\
\\\\\\\
				elseif y > 1 then\\\\\\\
					-- Move cursor up\\\\\\\
					setCursor(\\\\\\\
					    math.min( x, string.len( tLines[y - 1] ) + 1 ),\\\\\\\
					    y - 1\\\\\\\
					)\\\\\\\
				end\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.down then\\\\\\\
			-- Down\\\\\\\
			if not bMenu then\\\\\\\
				-- Move cursor down\\\\\\\
			    if nCompletion then\\\\\\\
			        -- Cycle completions\\\\\\\
                    nCompletion = nCompletion + 1\\\\\\\
                    if nCompletion > #tCompletions then\\\\\\\
                        nCompletion = 1\\\\\\\
                    end\\\\\\\
                    redrawLine(y)\\\\\\\
\\\\\\\
				elseif y < #tLines then\\\\\\\
				    -- Move cursor down\\\\\\\
					setCursor(\\\\\\\
                        math.min( x, string.len( tLines[y + 1] ) + 1 ),\\\\\\\
                        y + 1\\\\\\\
                    )\\\\\\\
				end\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.tab then\\\\\\\
			-- Tab\\\\\\\
			if not bMenu and not bReadOnly then\\\\\\\
			    if nCompletion and x == string.len(tLines[y]) + 1 then\\\\\\\
			        -- Accept autocomplete\\\\\\\
                    acceptCompletion()\\\\\\\
                else\\\\\\\
                    -- Indent line\\\\\\\
                    local sLine = tLines[y]\\\\\\\
                    tLines[y] = string.sub(sLine,1,x-1) .. \\\\\\\"  \\\\\\\" .. string.sub(sLine,x)\\\\\\\
                    setCursor( x + 2, y )\\\\\\\
                end\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.pageUp then\\\\\\\
			-- Page Up\\\\\\\
			if not bMenu then\\\\\\\
				-- Move up a page\\\\\\\
				local newY\\\\\\\
				if y - (h - 1) >= 1 then\\\\\\\
					newY = y - (h - 1)\\\\\\\
				else\\\\\\\
				    newY = 1\\\\\\\
				end\\\\\\\
                setCursor(\\\\\\\
				    math.min( x, string.len( tLines[newY] ) + 1 ),\\\\\\\
				    newY\\\\\\\
				)\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.pageDown then\\\\\\\
			-- Page Down\\\\\\\
			if not bMenu then\\\\\\\
				-- Move down a page\\\\\\\
				local newY\\\\\\\
				if y + (h - 1) <= #tLines then\\\\\\\
					newY = y + (h - 1)\\\\\\\
				else\\\\\\\
					newY = #tLines\\\\\\\
				end\\\\\\\
				local newX = math.min( x, string.len( tLines[newY] ) + 1 )\\\\\\\
				setCursor( newX, newY )\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.home then\\\\\\\
			-- Home\\\\\\\
			if not bMenu then\\\\\\\
				-- Move cursor to the beginning\\\\\\\
				if x > 1 then\\\\\\\
                    setCursor(1,y)\\\\\\\
                end\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys[\\\\\\\"end\\\\\\\"] then\\\\\\\
			-- End\\\\\\\
			if not bMenu then\\\\\\\
				-- Move cursor to the end\\\\\\\
				local nLimit = string.len( tLines[y] ) + 1\\\\\\\
				if x < nLimit then\\\\\\\
    				setCursor( nLimit, y )\\\\\\\
    		    end\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.left then\\\\\\\
			-- Left\\\\\\\
			if not bMenu then\\\\\\\
				if x > 1 then\\\\\\\
					-- Move cursor left\\\\\\\
    				setCursor( x - 1, y )\\\\\\\
				elseif x==1 and y>1 then\\\\\\\
    				setCursor( string.len( tLines[y-1] ) + 1, y - 1 )\\\\\\\
				end\\\\\\\
			else\\\\\\\
				-- Move menu left\\\\\\\
				nMenuItem = nMenuItem - 1\\\\\\\
				if nMenuItem < 1 then\\\\\\\
					nMenuItem = #tMenuItems\\\\\\\
				end\\\\\\\
				redrawMenu()\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.right then\\\\\\\
			-- Right\\\\\\\
			if not bMenu then\\\\\\\
			    local nLimit = string.len( tLines[y] ) + 1\\\\\\\
				if x < nLimit then\\\\\\\
					-- Move cursor right\\\\\\\
					setCursor( x + 1, y )\\\\\\\
			    elseif nCompletion and x == string.len(tLines[y]) + 1 then\\\\\\\
                    -- Accept autocomplete\\\\\\\
                    acceptCompletion()\\\\\\\
				elseif x==nLimit and y<#tLines then\\\\\\\
				    -- Go to next line\\\\\\\
				    setCursor( 1, y + 1 )\\\\\\\
				end\\\\\\\
			else\\\\\\\
				-- Move menu right\\\\\\\
				nMenuItem = nMenuItem + 1\\\\\\\
				if nMenuItem > #tMenuItems then\\\\\\\
					nMenuItem = 1\\\\\\\
				end\\\\\\\
				redrawMenu()\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.delete then\\\\\\\
			-- Delete\\\\\\\
			if not bMenu and not bReadOnly then\\\\\\\
			    local nLimit = string.len( tLines[y] ) + 1\\\\\\\
				if x < nLimit then\\\\\\\
					local sLine = tLines[y]\\\\\\\
					tLines[y] = string.sub(sLine,1,x-1) .. string.sub(sLine,x+1)\\\\\\\
					recomplete()\\\\\\\
					redrawLine(y)\\\\\\\
				elseif y<#tLines then\\\\\\\
					tLines[y] = tLines[y] .. tLines[y+1]\\\\\\\
					table.remove( tLines, y+1 )\\\\\\\
					recomplete()\\\\\\\
					redrawText()\\\\\\\
				end\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.backspace then\\\\\\\
			-- Backspace\\\\\\\
			if not bMenu and not bReadOnly then\\\\\\\
				if x > 1 then\\\\\\\
					-- Remove character\\\\\\\
					local sLine = tLines[y]\\\\\\\
					tLines[y] = string.sub(sLine,1,x-2) .. string.sub(sLine,x)\\\\\\\
			        setCursor( x - 1, y )\\\\\\\
				elseif y > 1 then\\\\\\\
					-- Remove newline\\\\\\\
					local sPrevLen = string.len( tLines[y-1] )\\\\\\\
					tLines[y-1] = tLines[y-1] .. tLines[y]\\\\\\\
					table.remove( tLines, y )\\\\\\\
					setCursor( sPrevLen + 1, y - 1 )\\\\\\\
					redrawText()\\\\\\\
				end\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.enter then\\\\\\\
			-- Enter\\\\\\\
			if not bMenu and not bReadOnly then\\\\\\\
				-- Newline\\\\\\\
				local sLine = tLines[y]\\\\\\\
				local _,spaces=string.find(sLine,\\\\\\\"^[ ]+\\\\\\\")\\\\\\\
				if not spaces then\\\\\\\
					spaces=0\\\\\\\
				end\\\\\\\
				tLines[y] = string.sub(sLine,1,x-1)\\\\\\\
				table.insert( tLines, y+1, string.rep(' ',spaces)..string.sub(sLine,x) )\\\\\\\
				setCursor( spaces + 1, y + 1 )\\\\\\\
				redrawText()\\\\\\\
\\\\\\\
			elseif bMenu then\\\\\\\
				-- Menu selection\\\\\\\
				doMenuItem( nMenuItem )\\\\\\\
\\\\\\\
			end\\\\\\\
\\\\\\\
		elseif param == keys.leftCtrl or param == keys.rightCtrl or param == keys.rightAlt then\\\\\\\
			-- Menu toggle\\\\\\\
			bMenu = not bMenu\\\\\\\
			if bMenu then\\\\\\\
				term.setCursorBlink( false )\\\\\\\
			else\\\\\\\
				term.setCursorBlink( true )\\\\\\\
			end\\\\\\\
			redrawMenu()\\\\\\\
\\\\\\\
		end\\\\\\\
		\\\\\\\
	elseif sEvent == \\\\\\\"char\\\\\\\" then\\\\\\\
		if not bMenu and not bReadOnly then\\\\\\\
			-- Input text\\\\\\\
			local sLine = tLines[y]\\\\\\\
			tLines[y] = string.sub(sLine,1,x-1) .. param .. string.sub(sLine,x)\\\\\\\
			setCursor( x + 1, y )\\\\\\\
\\\\\\\
		elseif bMenu then\\\\\\\
			-- Select menu items\\\\\\\
			for n,sMenuItem in ipairs( tMenuItems ) do\\\\\\\
				if string.lower(string.sub(sMenuItem,1,1)) == string.lower(param) then\\\\\\\
					doMenuItem( n )\\\\\\\
					break\\\\\\\
				end\\\\\\\
			end\\\\\\\
		end\\\\\\\
\\\\\\\
	elseif sEvent == \\\\\\\"paste\\\\\\\" then\\\\\\\
		if not bMenu and not bReadOnly then\\\\\\\
			-- Input text\\\\\\\
			local sLine = tLines[y]\\\\\\\
			tLines[y] = string.sub(sLine,1,x-1) .. param .. string.sub(sLine,x)\\\\\\\
			setCursor( x + string.len( param ), y )\\\\\\\
		end\\\\\\\
		\\\\\\\
	elseif sEvent == \\\\\\\"mouse_click\\\\\\\" then\\\\\\\
		if not bMenu then\\\\\\\
			if param == 1 then\\\\\\\
				-- Left click\\\\\\\
				local cx,cy = param2, param3\\\\\\\
				if cy < h then\\\\\\\
					local newY = math.min( math.max( scrollY + cy, 1 ), #tLines )\\\\\\\
					local newX = math.min( math.max( scrollX + cx, 1 ), string.len( tLines[newY] ) + 1 )\\\\\\\
					setCursor( newX, newY )\\\\\\\
				end\\\\\\\
			end\\\\\\\
		end\\\\\\\
		\\\\\\\
	elseif sEvent == \\\\\\\"mouse_scroll\\\\\\\" then\\\\\\\
		if not bMenu then\\\\\\\
			if param == -1 then\\\\\\\
				-- Scroll up\\\\\\\
				if scrollY > 0 then\\\\\\\
					-- Move cursor up\\\\\\\
					scrollY = scrollY - 1\\\\\\\
					redrawText()\\\\\\\
				end\\\\\\\
			\\\\\\\
			elseif param == 1 then\\\\\\\
				-- Scroll down\\\\\\\
				local nMaxScroll = #tLines - (h-1)\\\\\\\
				if scrollY < nMaxScroll then\\\\\\\
					-- Move cursor down\\\\\\\
					scrollY = scrollY + 1\\\\\\\
					redrawText()\\\\\\\
				end\\\\\\\
				\\\\\\\
			end\\\\\\\
		end\\\\\\\
\\\\\\\
	elseif sEvent == \\\\\\\"term_resize\\\\\\\" then\\\\\\\
	    w,h = term.getSize()\\\\\\\
        setCursor( x, y )\\\\\\\
        redrawMenu()\\\\\\\
        redrawText()\\\\\\\
\\\\\\\
	end\\\\\\\
end\\\\\\\
\\\\\\\
-- Cleanup\\\\\\\
term.clear()\\\\\\\
term.setCursorBlink( false )\\\\\\\
term.setCursorPos( 1, 1 )\\\"\",\
  \"F:firststeps\",\
  \"\\\"gui.printAppInfo(\\\\\\\"man\\\\\\\", kernel.findManual(\\\\\\\"firststeps\\\\\\\"))\\\"\",\
  \"F:hostname\",\
  \"\\\"gui.printAppInfo(\\\\\\\"net\\\\\\\", \\\\\\\"hostname is \\\\\\\"..os.getComputerLabel())\\\"\",\
  \"F:lsh\",\
  \"\\\"local bRunning = true\\\\\\\
local tCommandHistory = {}\\\\\\\
local tEnv = {\\\\\\\
	[\\\\\\\"exit\\\\\\\"] = function()\\\\\\\
		bRunning = false\\\\\\\
	end,\\\\\\\
	[\\\\\\\"_echo\\\\\\\"] = function( ... )\\\\\\\
	    return ...\\\\\\\
	end,\\\\\\\
}\\\\\\\
\\\\\\\
if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
setmetatable( tEnv, { __index = _ENV } )\\\\\\\
\\\\\\\
local label = os.getComputerLabel() or os.getComputerID()\\\\\\\
\\\\\\\
term.setTextColour( colours.yellow )\\\\\\\
print( os.version() )\\\\\\\
print( \\\\\\\"Manual Lua code interpreter. Call exit() to abort.\\\\\\\" )\\\\\\\
term.setTextColour( colours.white )\\\\\\\
\\\\\\\
while bRunning do\\\\\\\
	if security.getActiveUserStatus() then\\\\\\\
	    term.setTextColour( colours.lime )\\\\\\\
	else\\\\\\\
	    term.setTextColour( colours.orange )\\\\\\\
	end\\\\\\\
	write( _activeUser )\\\\\\\
	term.setTextColour( colours.lightGrey )\\\\\\\
	write( \\\\\\\"@\\\\\\\" )\\\\\\\
	term.setTextColour( colours.lightBlue )\\\\\\\
	write( label )\\\\\\\
	term.setTextColour( colours.lightGrey )\\\\\\\
	write( \\\\\\\"/\\\\\\\" )\\\\\\\
	term.setTextColour( colours.lightBlue )\\\\\\\
	write( shell.dir() )\\\\\\\
	if security.getActiveUserStatus() then\\\\\\\
	    term.setTextColour( colours.lime )\\\\\\\
	else\\\\\\\
	    term.setTextColour( colours.orange )\\\\\\\
	end\\\\\\\
	write( \\\\\\\" % \\\\\\\" )\\\\\\\
\\\\\\\
	term.setTextColour( colours.white )\\\\\\\
\\\\\\\
	local s = read( nil, tCommandHistory, function( sLine )\\\\\\\
	    local nStartPos = string.find( sLine, \\\\\\\"[a-zA-Z0-9_%.]+$\\\\\\\" )\\\\\\\
	    if nStartPos then\\\\\\\
	        sLine = string.sub( sLine, nStartPos )\\\\\\\
	    end\\\\\\\
	    if #sLine > 0 then\\\\\\\
            return textutils.complete( sLine, tEnv )\\\\\\\
        end\\\\\\\
        return nil\\\\\\\
	end )\\\\\\\
	term.setTextColour( colours.lightGrey )\\\\\\\
	table.insert( tCommandHistory, s )\\\\\\\
	\\\\\\\
	local nForcePrint = 0\\\\\\\
	local func, e = load( s, \\\\\\\"lua\\\\\\\", \\\\\\\"t\\\\\\\", tEnv )\\\\\\\
	local func2, e2 = load( \\\\\\\"return _echo(\\\\\\\"..s..\\\\\\\");\\\\\\\", \\\\\\\"lua\\\\\\\", \\\\\\\"t\\\\\\\", tEnv )\\\\\\\
	if not func then\\\\\\\
		if func2 then\\\\\\\
			func = func2\\\\\\\
			e = nil\\\\\\\
			nForcePrint = 1\\\\\\\
		end\\\\\\\
	else\\\\\\\
		if func2 then\\\\\\\
			func = func2\\\\\\\
		end\\\\\\\
	end\\\\\\\
	\\\\\\\
	if func then\\\\\\\
        local tResults = { pcall( func ) }\\\\\\\
        if tResults[1] then\\\\\\\
        	local n = 1\\\\\\\
        	while (tResults[n + 1] ~= nil) or (n <= nForcePrint) do\\\\\\\
        	    local value = tResults[ n + 1 ]\\\\\\\
        	    if type( value ) == \\\\\\\"table\\\\\\\" then\\\\\\\
            	    local ok, serialised = pcall( textutils.serialise, value )\\\\\\\
            	    if ok then\\\\\\\
            	        print( serialised )\\\\\\\
            	    else\\\\\\\
            	        print( tostring( value ) )\\\\\\\
            	    end\\\\\\\
            	else\\\\\\\
            	    print( tostring( value ) )\\\\\\\
            	end\\\\\\\
        		n = n + 1\\\\\\\
        	end\\\\\\\
        else\\\\\\\
        	printError( tResults[2] )\\\\\\\
        end\\\\\\\
    else\\\\\\\
    	printError( e )\\\\\\\
    end\\\\\\\
    \\\\\\\
end\\\"\",\
  \"F:man\",\
  \"\\\"local tArgs = {...}\\\\\\\
\\\\\\\
if #tArgs < 1 then\\\\\\\
 gui.printAppInfo(\\\\\\\"man\\\\\\\", \\\\\\\"type 'ls system/man-pages' or 'manpages'\\\\\\\")\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"man\\\\\\\", kernel.findManual(tArgs[1]))\\\\\\\
end\\\"\",\
  \"F:manedit\",\
  \"\\\"local tArgs = {...}\\\\\\\
\\\\\\\
if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if #tArgs < 1 then\\\\\\\
 gui.printAppInfo(\\\\\\\"edit\\\\\\\", \\\\\\\"filename not specified\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
shell.run(\\\\\\\"/rom/programs/edit /etc/manuals/\\\\\\\"..tArgs[1])\\\"\",\
  \"F:manpages\",\
  \"\\\"shell.run(\\\\\\\"/rom/programs/list /etc/manuals\\\\\\\")\\\"\",\
  \"F:mkusr\",\
  \"\\\"local tArgs = {...}\\\\\\\
\\\\\\\
if #tArgs < 2 then\\\\\\\
 gui.printAppInfo(\\\\\\\"security\\\\\\\", \\\\\\\"specify username and password\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if fs.exists(\\\\\\\"/etc/passwd/\\\\\\\"..tArgs[1]..\\\\\\\".dat\\\\\\\") and not fs.isDir(\\\\\\\"/etc/passwd/\\\\\\\"..tArgs[1]..\\\\\\\".dat\\\\\\\") then\\\\\\\
 gui.printAppInfo(\\\\\\\"security\\\\\\\", \\\\\\\"user already exists\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if security.passbyte(tArgs[1], tArgs[2]) then\\\\\\\
 gui.printAppSuccess(\\\\\\\"security\\\\\\\", \\\\\\\"user \\\\\\\"..tArgs[1]..\\\\\\\" registered\\\\\\\")\\\\\\\
 log.writeSecurity(\\\\\\\"user \\\\\\\"..tArgs[1]..\\\\\\\" registered\\\\\\\")\\\\\\\
 fs.makeDir(\\\\\\\"/home/\\\\\\\"..tArgs[1])\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"security\\\\\\\", \\\\\\\"failed to register user\\\\\\\")\\\\\\\
 log.writeSecurity(\\\\\\\"failed to register user\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:netutil1\",\
  \"\\\"-- testing\\\\\\\
net.openModems()\\\\\\\
net.setWorkstationStatus(true)\\\\\\\
print(tostring(net.getWorkstationStatus()))\\\"\",\
  \"F:passwd\",\
  \"\\\"local tArgs = {...}\\\\\\\
\\\\\\\
if #tArgs < 2 then\\\\\\\
 gui.printAppInfo(\\\\\\\"security\\\\\\\", \\\\\\\"specify username and password\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if fs.exists(\\\\\\\"/system/data/users/\\\\\\\"..tArgs[1]..\\\\\\\".dat\\\\\\\") and not fs.isDir(\\\\\\\"/system/data/users/\\\\\\\"..tArgs[1]..\\\\\\\".dat\\\\\\\") then\\\\\\\
 if security.passbyte(tArgs[1], tArgs[2]) then\\\\\\\
  gui.printAppSuccess(\\\\\\\"security\\\\\\\", \\\\\\\"password of \\\\\\\"..tArgs[1]..\\\\\\\" changed\\\\\\\")\\\\\\\
  log.writeSecurity(\\\\\\\"password of \\\\\\\"..tArgs[1]..\\\\\\\" changed\\\\\\\")\\\\\\\
 else\\\\\\\
  gui.printAppInfo(\\\\\\\"security\\\\\\\", \\\\\\\"failed to change password\\\\\\\")\\\\\\\
  log.writeSecurity(\\\\\\\"failed to change password\\\\\\\")\\\\\\\
 end\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"security\\\\\\\", \\\\\\\"user does not exist\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:rmusr\",\
  \"\\\"local tArgs = { ... }\\\\\\\
\\\\\\\
if #tArgs < 1 then\\\\\\\
 gui.printAppInfo( \\\\\\\"security\\\\\\\", \\\\\\\"username not specified\\\\\\\" )\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if not security.getSU() or tArgs[1] == \\\\\\\"root\\\\\\\" then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
local pathA = \\\\\\\"/etc/passwd/\\\\\\\"..tArgs[1]..\\\\\\\".dat\\\\\\\"\\\\\\\
local pathB = \\\\\\\"/etc/passwd/.shadow/\\\\\\\"..tArgs[1]..\\\\\\\".usr\\\\\\\"\\\\\\\
local pathC = \\\\\\\"/home/\\\\\\\"..tArgs[1]\\\\\\\
\\\\\\\
if fs.exists(pathA) then\\\\\\\
 if gui.request(\\\\\\\"remove user record\\\\\\\") then\\\\\\\
  fs.delete( pathA )\\\\\\\
  if fs.exists(pathB) then\\\\\\\
   fs.delete( pathB )\\\\\\\
  end\\\\\\\
  fs.delete( pathC )\\\\\\\
 end\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"security\\\\\\\", \\\\\\\"user does not exist\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:script\",\
  \"\\\"local tArgs = {...}\\\\\\\
\\\\\\\
if #tArgs >= 1 then\\\\\\\
 shell.executeScript(shell.resolve(tArgs[1]))\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"script\\\\\\\", \\\\\\\"filename not specified\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:sh\",\
  \"\\\"local tArgs = {...}\\\\\\\
\\\\\\\
local parentShell = shell\\\\\\\
\\\\\\\
local bExit = false\\\\\\\
local sDir = (parentShell and parentShell.dir()) or \\\\\\\"\\\\\\\"\\\\\\\
local sPath = (parentShell and parentShell.path()) or \\\\\\\".:/rom/programs\\\\\\\"\\\\\\\
local tAliases = (parentShell and parentShell.aliases()) or {}\\\\\\\
local tProgramStack = {}\\\\\\\
\\\\\\\
local shell = {}\\\\\\\
local tEnv = {\\\\\\\
	[\\\\\\\"shell\\\\\\\"] = shell,\\\\\\\
}\\\\\\\
\\\\\\\
local function findArg(arg)\\\\\\\
 for _,v in ipairs(tArgs) do\\\\\\\
  if v == arg then\\\\\\\
   return true\\\\\\\
  end\\\\\\\
 end\\\\\\\
 return false\\\\\\\
end\\\\\\\
\\\\\\\
-- Colours\\\\\\\
local promptColour, textColour, bgColour\\\\\\\
if term.isColour() then\\\\\\\
	promptColour = colours.yellow\\\\\\\
	textColour = colours.white\\\\\\\
	bgColour = colours.black\\\\\\\
else\\\\\\\
	promptColour = colours.white\\\\\\\
	textColour = colours.white\\\\\\\
	bgColour = colours.black\\\\\\\
end\\\\\\\
\\\\\\\
\\\\\\\
local function run( _sCommand, ... )\\\\\\\
	local sPath = shell.resolveProgram( _sCommand )\\\\\\\
	if sPath ~= nil then\\\\\\\
		tProgramStack[#tProgramStack + 1] = sPath\\\\\\\
   		local result = os.run( tEnv, sPath, ... )\\\\\\\
		tProgramStack[#tProgramStack] = nil\\\\\\\
		return result\\\\\\\
   	else\\\\\\\
    	printError( \\\\\\\"No such program\\\\\\\" )\\\\\\\
    	return false\\\\\\\
    end\\\\\\\
end\\\\\\\
\\\\\\\
local function runLine( _sLine )\\\\\\\
	local tWords = {}\\\\\\\
	for match in string.gmatch( _sLine, \\\\\\\"[^ \\\\\\\\t]+\\\\\\\" ) do\\\\\\\
		table.insert( tWords, match )\\\\\\\
	end\\\\\\\
\\\\\\\
	local sCommand = tWords[1]\\\\\\\
	if sCommand then\\\\\\\
		return run( sCommand, unpack( tWords, 2 ) )\\\\\\\
	end\\\\\\\
	return false\\\\\\\
end\\\\\\\
\\\\\\\
-- Install shell API\\\\\\\
function shell.run( ... )\\\\\\\
	return runLine( table.concat( { ... }, \\\\\\\" \\\\\\\" ) )\\\\\\\
end\\\\\\\
\\\\\\\
function shell.exit()\\\\\\\
    bExit = true\\\\\\\
end\\\\\\\
\\\\\\\
function shell.dir()\\\\\\\
	return sDir\\\\\\\
end\\\\\\\
\\\\\\\
function shell.setDir( _sDir )\\\\\\\
	sDir = _sDir\\\\\\\
end\\\\\\\
\\\\\\\
function shell.path()\\\\\\\
	return sPath\\\\\\\
end\\\\\\\
\\\\\\\
function shell.setPath( _sPath )\\\\\\\
	sPath = _sPath\\\\\\\
end\\\\\\\
\\\\\\\
function shell.resolve( _sPath )\\\\\\\
	local sStartChar = string.sub( _sPath, 1, 1 )\\\\\\\
	if sStartChar == \\\\\\\"/\\\\\\\" or sStartChar == \\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\" then\\\\\\\
		return fs.combine( \\\\\\\"\\\\\\\", _sPath )\\\\\\\
	else\\\\\\\
		return fs.combine( sDir, _sPath )\\\\\\\
	end\\\\\\\
end\\\\\\\
\\\\\\\
function shell.resolveProgram( _sCommand )\\\\\\\
	-- Substitute aliases firsts\\\\\\\
	if tAliases[ _sCommand ] ~= nil then\\\\\\\
		_sCommand = tAliases[ _sCommand ]\\\\\\\
	end\\\\\\\
\\\\\\\
    -- If the path is a global path, use it directly\\\\\\\
    local sStartChar = string.sub( _sCommand, 1, 1 )\\\\\\\
    if sStartChar == \\\\\\\"/\\\\\\\" or sStartChar == \\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\" then\\\\\\\
    	local sPath = fs.combine( \\\\\\\"\\\\\\\", _sCommand )\\\\\\\
    	if fs.exists( sPath ) and not fs.isDir( sPath ) then\\\\\\\
			return sPath\\\\\\\
    	end\\\\\\\
		return nil\\\\\\\
    end\\\\\\\
    \\\\\\\
 	-- Otherwise, look on the path variable\\\\\\\
    for sPath in string.gmatch(sPath, \\\\\\\"[^:]+\\\\\\\") do\\\\\\\
    	sPath = fs.combine( shell.resolve( sPath ), _sCommand )\\\\\\\
    	if fs.exists( sPath ) and not fs.isDir( sPath ) then\\\\\\\
			return sPath\\\\\\\
    	end\\\\\\\
    end\\\\\\\
	\\\\\\\
	-- Not found\\\\\\\
	return nil\\\\\\\
end\\\\\\\
\\\\\\\
function shell.programs( _bIncludeHidden )\\\\\\\
	local tItems = {}\\\\\\\
	\\\\\\\
	-- Add programs from the path\\\\\\\
    for sPath in string.gmatch(sPath, \\\\\\\"[^:]+\\\\\\\") do\\\\\\\
    	sPath = shell.resolve( sPath )\\\\\\\
		if fs.isDir( sPath ) then\\\\\\\
			local tList = fs.list( sPath )\\\\\\\
			for n,sFile in pairs( tList ) do\\\\\\\
				if not fs.isDir( fs.combine( sPath, sFile ) ) and\\\\\\\
				   (_bIncludeHidden or string.sub( sFile, 1, 1 ) ~= \\\\\\\".\\\\\\\") then\\\\\\\
					tItems[ sFile ] = true\\\\\\\
				end\\\\\\\
			end\\\\\\\
		end\\\\\\\
    end	\\\\\\\
\\\\\\\
	-- Sort and return\\\\\\\
	local tItemList = {}\\\\\\\
	for sItem, b in pairs( tItems ) do\\\\\\\
		table.insert( tItemList, sItem )\\\\\\\
	end\\\\\\\
	table.sort( tItemList )\\\\\\\
	return tItemList\\\\\\\
end\\\\\\\
\\\\\\\
function shell.getRunningProgram()\\\\\\\
	if #tProgramStack > 0 then\\\\\\\
		return tProgramStack[#tProgramStack]\\\\\\\
	end\\\\\\\
	return nil\\\\\\\
end\\\\\\\
\\\\\\\
function shell.setAlias( _sCommand, _sProgram )\\\\\\\
	tAliases[ _sCommand ] = _sProgram\\\\\\\
end\\\\\\\
\\\\\\\
function shell.clearAlias( _sCommand )\\\\\\\
	tAliases[ _sCommand ] = nil\\\\\\\
end\\\\\\\
\\\\\\\
function shell.aliases()\\\\\\\
	-- Add aliases\\\\\\\
	local tCopy = {}\\\\\\\
	for sAlias, sCommand in pairs( tAliases ) do\\\\\\\
		tCopy[sAlias] = sCommand\\\\\\\
	end\\\\\\\
	return tCopy\\\\\\\
end\\\\\\\
\\\\\\\
-- Custom shell API functions\\\\\\\
\\\\\\\
function shell.executeScript(path)\\\\\\\
 if not fs.exists(path) or fs.isDir(path) then\\\\\\\
  return \\\\\\\"file does not exist\\\\\\\"\\\\\\\
 else\\\\\\\
  local t = luaex.iterateFileLines(path)\\\\\\\
  if string.find(t[1], \\\\\\\"@ @ !! TESSERACT SCRIPT HEADER\\\\\\\") or t[1] == \\\\\\\"@ @ !! TESSERACT SCRIPT HEADER\\\\\\\" then\\\\\\\
   for _,cmd in pairs(t) do\\\\\\\
    shell.run(cmd)\\\\\\\
   end\\\\\\\
  else\\\\\\\
   return \\\\\\\"script header is missing or corrupt\\\\\\\" \\\\\\\
  end\\\\\\\
 end\\\\\\\
end\\\\\\\
\\\\\\\
function shell.getActiveUserShell()\\\\\\\
 if fs.exists(\\\\\\\"/etc/passwd/.shadow/\\\\\\\".._G[\\\\\\\"_activeUser\\\\\\\"]..\\\\\\\".usr\\\\\\\") then\\\\\\\
  local ud = dofile(\\\\\\\"/etc/passwd/.shadow/\\\\\\\".._G[\\\\\\\"_activeUser\\\\\\\"]..\\\\\\\".usr\\\\\\\")\\\\\\\
  return ud.shell or \\\\\\\"/bin/sh\\\\\\\"\\\\\\\
 else\\\\\\\
  return \\\\\\\"/bin/sh\\\\\\\"\\\\\\\
 end\\\\\\\
end\\\\\\\
\\\\\\\
-- Run custom shells\\\\\\\
if findArg(\\\\\\\"--force\\\\\\\") or findArg(\\\\\\\"-f\\\\\\\") then\\\\\\\
 kernel.writeMessage(\\\\\\\"ignoring user shell settings\\\\\\\")\\\\\\\
elseif shell.getActiveUserShell() ~= \\\\\\\"/bin/sh\\\\\\\" then\\\\\\\
 shell.run(shell.getActiveUserShell())\\\\\\\
 kernel.shutdown(false)\\\\\\\
end\\\\\\\
	\\\\\\\
term.setBackgroundColor( bgColour )\\\\\\\
term.setTextColour( promptColour )\\\\\\\
print( os.version() )\\\\\\\
term.setTextColour( textColour )\\\\\\\
\\\\\\\
local label = os.getComputerLabel() or os.getComputerID()\\\\\\\
\\\\\\\
-- Read commands and execute them\\\\\\\
local tCommandHistory = {}\\\\\\\
while not bExit do\\\\\\\
	term.setBackgroundColor( bgColour )\\\\\\\
	if security.getSU() then\\\\\\\
		if security.getActiveUserStatus() then\\\\\\\
	     term.setTextColour( colours.lime )\\\\\\\
	    else\\\\\\\
	     term.setTextColour( colours.orange )\\\\\\\
		end\\\\\\\
	else\\\\\\\
	 term.setTextColour( colours.cyan )\\\\\\\
    end\\\\\\\
	write( _activeUser )\\\\\\\
	term.setTextColour( colours.lightGrey )\\\\\\\
	write( \\\\\\\"@\\\\\\\" )\\\\\\\
	term.setTextColour( colours.lightBlue )\\\\\\\
	write( label )\\\\\\\
	term.setTextColour( colours.lightGrey )\\\\\\\
	write( \\\\\\\"/\\\\\\\" )\\\\\\\
	term.setTextColour( colours.lightBlue )\\\\\\\
	write( shell.dir() )\\\\\\\
	if security.getSU() then\\\\\\\
	 if security.getActiveUserStatus() then\\\\\\\
	  term.setTextColour( colours.lime )\\\\\\\
	 else\\\\\\\
	  term.setTextColour( colours.orange )\\\\\\\
	 end\\\\\\\
	 write( \\\\\\\" # \\\\\\\" )\\\\\\\
	else\\\\\\\
	 term.setTextColour( colours.cyan )\\\\\\\
	 write( \\\\\\\" $ \\\\\\\" )\\\\\\\
    end\\\\\\\
	term.setTextColour( textColour )\\\\\\\
\\\\\\\
	local sLine = read( nil, tCommandHistory )\\\\\\\
	table.insert( tCommandHistory, sLine )\\\\\\\
	runLine( sLine )\\\\\\\
end\\\\\\\
\\\\\\\
-- Custom shutdown code goes here\\\"\",\
  \"F:systeminfo\",\
  \"\\\"local tArgs = {...}\\\\\\\
local err = true\\\\\\\
local function findArg(arg)\\\\\\\
 for _,v in ipairs(tArgs) do\\\\\\\
  if v == arg then\\\\\\\
   return true\\\\\\\
  end\\\\\\\
 end\\\\\\\
 return false\\\\\\\
end\\\\\\\
\\\\\\\
if findArg(\\\\\\\"--os-version\\\\\\\") then\\\\\\\
 err = false\\\\\\\
 gui.printAppInfo(\\\\\\\"systeminfo\\\\\\\", os.version())\\\\\\\
end\\\\\\\
if findArg(\\\\\\\"--shell-path\\\\\\\") then\\\\\\\
 err = false\\\\\\\
 gui.printAppInfo(\\\\\\\"systeminfo\\\\\\\", shell.path())\\\\\\\
end\\\\\\\
if findArg(\\\\\\\"--computer-info\\\\\\\") then\\\\\\\
 err = false\\\\\\\
 gui.printAppInfo(\\\\\\\"systeminfo\\\\\\\", \\\\\\\"ID \\\\\\\"..os.getComputerID())\\\\\\\
 gui.printAppInfo(\\\\\\\"systeminfo\\\\\\\", \\\\\\\"Computer labeled as \\\\\\\"..os.getComputerLabel())\\\\\\\
end\\\\\\\
if #tArgs < 1 or err then\\\\\\\
 gui.printAppInfo(\\\\\\\"systeminfo\\\\\\\", \\\\\\\"arguments not specified\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:tpm-install\",\
  \"\\\"local tArgs = {...}\\\\\\\
local packages = config.load(\\\\\\\"/etc/tpm/package.dat\\\\\\\")\\\\\\\
local temp = config.load(\\\\\\\"/etc/tpm/packageInstalled.dat\\\\\\\")\\\\\\\
local found, value\\\\\\\
\\\\\\\
if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if #tArgs < 1 then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"package name not specified\\\\\\\")\\\\\\\
 return\\\\\\\
elseif not packages then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"package.dat is missing or corrupt\\\\\\\")\\\\\\\
 log.writeMessage(\\\\\\\"package.dat unable to be traversed\\\\\\\")\\\\\\\
 return\\\\\\\
elseif not temp then\\\\\\\
 shell.executeScript(\\\\\\\"/etc/scripts/tpm-recache.tsf\\\\\\\")\\\\\\\
end\\\\\\\
\\\\\\\
found, value = search.traverseKey(temp, tArgs[1])\\\\\\\
if found and value then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"package already installed\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"traversing package.dat\\\\\\\")\\\\\\\
local ok, pack = search.traverseValue(packages, tArgs[1])\\\\\\\
if ok and pack then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"found corresponding package\\\\\\\")\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"downloading API files [1/2]\\\\\\\")\\\\\\\
 local numapi = 1\\\\\\\
 local numbin = 1\\\\\\\
 local APIInstallFlag = false\\\\\\\
 for k,v in pairs(pack.apis) do\\\\\\\
  if tpm.downloadAPI(k, v) then\\\\\\\
   APIInstallFlag = true\\\\\\\
   gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"downloaded API \\\\\\\"..k..\\\\\\\" [\\\\\\\"..tostring(numapi)..\\\\\\\"]\\\\\\\")\\\\\\\
  else\\\\\\\
   gui.printAppWarning(\\\\\\\"tpm\\\\\\\", \\\\\\\"failed to download API \\\\\\\"..k)\\\\\\\
  end\\\\\\\
  numapi = numapi + 1\\\\\\\
 end\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"downloading binaries [2/2]\\\\\\\")\\\\\\\
 for k,v in pairs(pack.bins) do\\\\\\\
  if tpm.downloadBinary(k, v) then\\\\\\\
   gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"downloaded binary \\\\\\\"..k..\\\\\\\" [\\\\\\\"..tostring(numbin)..\\\\\\\"]\\\\\\\")\\\\\\\
  else\\\\\\\
   gui.printAppWarning(\\\\\\\"tpm\\\\\\\", \\\\\\\"failed to download binary \\\\\\\"..k)\\\\\\\
  end\\\\\\\
  numbin = numbin + 1\\\\\\\
 end\\\\\\\
 table.insert(temp, pack.name)\\\\\\\
 log.writeMessage(\\\\\\\"New package downloaded and installed\\\\\\\")\\\\\\\
 config.save(temp, \\\\\\\"/etc/tpm/packageInstalled.dat\\\\\\\")\\\\\\\
 gui.printAppSuccess(\\\\\\\"tpm\\\\\\\", \\\\\\\"package installed\\\\\\\")\\\\\\\
 if APIInstallFlag then\\\\\\\
  if gui.request(\\\\\\\"Assemblies were installed, restart\\\\\\\") then\\\\\\\
   kernel.reboot(false)\\\\\\\
  end\\\\\\\
 end\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"unable to find id for \\\\\\\"..tArgs[1])\\\\\\\
end\\\"\",\
  \"F:tpm-list\",\
  \"\\\"local tArgs = {...}\\\\\\\
local packages = config.load(\\\\\\\"/etc/tpm/package.dat\\\\\\\")\\\\\\\
local packageInstalled = config.load(\\\\\\\"/etc/tpm/packageInstalled.dat\\\\\\\")\\\\\\\
\\\\\\\
if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if not packages then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"package.dat is missing or corrupt\\\\\\\")\\\\\\\
 log.writeMessage(\\\\\\\"package.dat unable to be traversed\\\\\\\")\\\\\\\
 return\\\\\\\
elseif not packageInstalled then\\\\\\\
 shell.executeScript(\\\\\\\"/etc/scripts/tpm-recache.tsf\\\\\\\")\\\\\\\
end\\\\\\\
\\\\\\\
if search.findValue(tArgs, \\\\\\\"available\\\\\\\") then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"traversing package.dat\\\\\\\")\\\\\\\
 for k, v in pairs(packages) do\\\\\\\
  gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"found package identifier \\\\\\\"..v.name)\\\\\\\
 end\\\\\\\
elseif search.findValue(tArgs, \\\\\\\"installed\\\\\\\") then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"traversing packageInstalled.dat\\\\\\\")\\\\\\\
 for k, v in pairs(packageInstalled) do\\\\\\\
  gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"found package identifier \\\\\\\"..v)\\\\\\\
 end\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"specify listing type\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:tpm-recache\",\
  \"\\\"if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"redownloading package.dat\\\\\\\")\\\\\\\
if tpm.getPaste(\\\\\\\"/etc/tpm/package.dat\\\\\\\", \\\\\\\"0YScZtUc\\\\\\\", true) then\\\\\\\
 gui.printAppSuccess(\\\\\\\"tpm\\\\\\\", \\\\\\\"package cache updated\\\\\\\")\\\\\\\
 log.writeMessage(\\\\\\\"package cache updated\\\\\\\")\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"failed to update package cache\\\\\\\")\\\\\\\
 log.writeMessage(\\\\\\\"failed to update package cache\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:tpm-remove\",\
  \"\\\"local tArgs = {...}\\\\\\\
local packages = config.load(\\\\\\\"/etc/tpm/package.dat\\\\\\\")\\\\\\\
local temp = config.load(\\\\\\\"/etc/tpm/packageInstalled.dat\\\\\\\")\\\\\\\
local found, value\\\\\\\
\\\\\\\
if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if #tArgs < 1 then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"package name not specified\\\\\\\")\\\\\\\
 return\\\\\\\
elseif not packages then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"package.dat is missing or corrupt\\\\\\\")\\\\\\\
 log.writeMessage(\\\\\\\"package.dat unable to be traversed\\\\\\\")\\\\\\\
 return\\\\\\\
elseif not temp then\\\\\\\
 shell.executeScript(\\\\\\\"/etc/scripts/tpm-recache.tsf\\\\\\\")\\\\\\\
end\\\\\\\
\\\\\\\
\\\\\\\
gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"traversing package.dat\\\\\\\")\\\\\\\
local ok, pack = search.traverseValue(packages, tArgs[1])\\\\\\\
if ok and pack then\\\\\\\
 found, value = search.traverseKey(temp, pack.name)\\\\\\\
 if found and value then\\\\\\\
  temp[value] = nil\\\\\\\
 else\\\\\\\
  gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"package missing\\\\\\\")\\\\\\\
  return\\\\\\\
 end\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"found corresponding package\\\\\\\")\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"removing API files [1/2]\\\\\\\")\\\\\\\
 local numapi = 1\\\\\\\
 local numbin = 1\\\\\\\
 local APIRemovalFlag = false\\\\\\\
 for k,v in pairs(pack.apis) do\\\\\\\
  if fs.exists(tpm.toPackageAPI(k)) and not fs.isDir(tpm.toPackageAPI(k)) then\\\\\\\
   fs.delete(tpm.toPackageAPI(k))\\\\\\\
   APIRemovalFlag = true\\\\\\\
   gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"removed API \\\\\\\"..k..\\\\\\\" [\\\\\\\"..tostring(numapi)..\\\\\\\"]\\\\\\\")\\\\\\\
  else\\\\\\\
   gui.printAppWarning(\\\\\\\"tpm\\\\\\\", \\\\\\\"failed to remove API \\\\\\\"..k)\\\\\\\
  end\\\\\\\
  numapi = numapi + 1\\\\\\\
 end\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"removing binaries [2/2]\\\\\\\")\\\\\\\
 for k,v in pairs(pack.bins) do\\\\\\\
  if fs.exists(tpm.toPackageBinary(k)) and not fs.isDir(tpm.toPackageBinary(k)) then\\\\\\\
   fs.delete(tpm.toPackageBinary(k))\\\\\\\
   gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"removed binary \\\\\\\"..k..\\\\\\\" [\\\\\\\"..tostring(numbin)..\\\\\\\"]\\\\\\\")\\\\\\\
  else\\\\\\\
   gui.printAppWarning(\\\\\\\"tpm\\\\\\\", \\\\\\\"failed to remove binary \\\\\\\"..k)\\\\\\\
  end\\\\\\\
  numbin = numbin + 1\\\\\\\
 end\\\\\\\
 if APIRemovalFlag then\\\\\\\
  if gui.request(\\\\\\\"Assemblies were removed, restart\\\\\\\") then\\\\\\\
   kernel.reboot(false)\\\\\\\
  end\\\\\\\
 end\\\\\\\
 config.save(temp, \\\\\\\"/etc/tpm/packageInstalled.dat\\\\\\\")\\\\\\\
 log.writeMessage(\\\\\\\"Removed package \\\\\\\"..tArgs[1])\\\\\\\
 gui.printAppSuccess(\\\\\\\"tpm\\\\\\\", \\\\\\\"package removed\\\\\\\")\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"unable to find id for \\\\\\\"..tArgs[1])\\\\\\\
end\\\"\",\
  \"F:tpm-repair\",\
  \"\\\"if not security.getSU() then\\\\\\\
 exception.throw(\\\\\\\"RestrictedOpsException\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if not config.load(\\\\\\\"/etc/tpm/packageInstalled.dat\\\\\\\") then\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"packageInstalled.dat is missing or corrupt\\\\\\\")\\\\\\\
 if gui.request(\\\\\\\"Repair TPM data files\\\\\\\") then\\\\\\\
  config.save({}, \\\\\\\"/etc/tpm/packageInstalled.dat\\\\\\\")\\\\\\\
  gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"package registry reconstructed\\\\\\\")\\\\\\\
 end\\\\\\\
else\\\\\\\
 gui.printAppInfo(\\\\\\\"tpm\\\\\\\", \\\\\\\"packageInstalled.dat is correctly readable\\\\\\\")\\\\\\\
end\\\"\",\
  \"F:tty\",\
  \"\\\"local x, y = term.getSize()\\\\\\\
gui.printAppInfo(\\\\\\\"tty\\\\\\\", \\\\\\\"terminal object size is \\\\\\\"..tostring(x)..\\\\\\\"x\\\\\\\"..tostring(y))\\\\\\\
\\\"\",\
  \"F:uname\",\
  \"\\\"gui.printAppInfo(\\\\\\\"security\\\\\\\", \\\\\\\"active username is \\\\\\\".._activeUser)\\\"\",\
}",
  "D:boot",
  "{\
  \"F:boot.conf\",\
  \"\\\"{\\\\\\\
  preferredBootloader = \\\\\\\"/boot/loaders/tesseract\\\\\\\",\\\\\\\
}\\\"\",\
  \"D:loaders\",\
  \"{\\\
  \\\"F:tesseract\\\",\\\
  \\\"\\\\\\\"local oldReadOnly = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"isReadOnly\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldMove = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"move\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldDelete = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"delete\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldHttpGet = _G[\\\\\\\\\\\\\\\"http\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"get\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldError = _G[\\\\\\\\\\\\\\\"error\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Initialized system boot log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeSyslog(\\\\\\\\\\\\\\\"Initialized primary system log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeMessage(\\\\\\\\\\\\\\\"Initialized secondary system log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeSecurity(\\\\\\\\\\\\\\\"Initialized security/access log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeShutdown(\\\\\\\\\\\\\\\"Initialized shutdown log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeAuth(\\\\\\\\\\\\\\\"Initialized authorization log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
sleep(0.25)\\\\\\\\\\\\\\\
if http then\\\\\\\\\\\\\\\
 gui.printBootSuccess(\\\\\\\\\\\\\\\"HTTP detection succeeded\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
else\\\\\\\\\\\\\\\
 gui.printBootWarning(\\\\\\\\\\\\\\\"HTTP detection failed\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
sleep(0.5)\\\\\\\\\\\\\\\
shell.run(\\\\\\\\\\\\\\\"/etc/autorun\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
gui.printBootWarning(\\\\\\\\\\\\\\\"Enumerating user assemblies...\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
kernel.loadUserAssemblies(false)\\\\\\\\\\\\\\\
sleep(0.25)\\\\\\\\\\\\\\\
gui.printBootWarning(\\\\\\\\\\\\\\\"Initiating security protocols\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"isReadOnly\\\\\\\\\\\\\\\"] = function(path)\\\\\\\\\\\\\\\
 local find1 = shell.resolve(path)\\\\\\\\\\\\\\\
 if string.find(find1, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return false\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return true\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find1 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find1 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return true\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldReadOnly(path)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"move\\\\\\\\\\\\\\\"] = function(path1, path2)\\\\\\\\\\\\\\\
 local find2 = shell.resolve(path1)\\\\\\\\\\\\\\\
 if string.find(find2, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return nil\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find2 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find2 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return nil\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldMove(path1, path2)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"delete\\\\\\\\\\\\\\\"] = function(path)\\\\\\\\\\\\\\\
 local find3 = shell.resolve(path)\\\\\\\\\\\\\\\
 if string.find(find3, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return nil\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find3 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find3 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return nil\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldDelete(path)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"http\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"get\\\\\\\\\\\\\\\"] = function(url, headers)\\\\\\\\\\\\\\\
 log.writeSecurity(\\\\\\\\\\\\\\\"Downloaded contents of \\\\\\\\\\\\\\\"..url)\\\\\\\\\\\\\\\
 return oldHttpGet(url, headers)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"error\\\\\\\\\\\\\\\"] = function(text, lvl)\\\\\\\\\\\\\\\
 local x = lvl or 2\\\\\\\\\\\\\\\
 local logger = fs.open(\\\\\\\\\\\\\\\"/etc/errorLog\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 logger.writeLine(tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"..text)\\\\\\\\\\\\\\\
 logger.close()\\\\\\\\\\\\\\\
 oldError(text, x or 1)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native\\\\\\\\\\\\\\\", {})\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.check\\\\\\\\\\\\\\\", oldReadOnly)\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.move\\\\\\\\\\\\\\\", oldMove)\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.delete\\\\\\\\\\\\\\\", oldDelete)\\\\\\\\\\\\\\\
rawset(http, \\\\\\\\\\\\\\\"_synchronise\\\\\\\\\\\\\\\", oldHttpGet)\\\\\\\\\\\\\\\
rawset(os, \\\\\\\\\\\\\\\"_exception\\\\\\\\\\\\\\\", oldError)\\\\\\\\\\\\\\\
gui.printBootSuccess(\\\\\\\\\\\\\\\"Boot sequence stage 2 complete\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
sleep(2)\\\\\\\\\\\\\\\
kernel.clear()\\\\\\\\\\\\\\\
shell.run(\\\\\\\\\\\\\\\"/etc/auth\\\\\\\\\\\\\\\")\\\\\\\"\\\",\\\
  \\\"F:tesseract-boot-splash\\\",\\\
  \\\"\\\\\\\"local function annotateLoading(txt, array, delay)\\\\\\\\\\\\\\\
 for _, v in ipairs(array) do\\\\\\\\\\\\\\\
  gui.printColoredTextLine(18, txt..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v)\\\\\\\\\\\\\\\
  sleep(delay or 1.5)\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local oldReadOnly = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"isReadOnly\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldMove = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"move\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldDelete = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"delete\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldHttpGet = _G[\\\\\\\\\\\\\\\"http\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"get\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldError = _G[\\\\\\\\\\\\\\\"error\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Initialized system boot log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeSyslog(\\\\\\\\\\\\\\\"Initialized primary system log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeMessage(\\\\\\\\\\\\\\\"Initialized secondary system log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeSecurity(\\\\\\\\\\\\\\\"Initialized security/access log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeShutdown(\\\\\\\\\\\\\\\"Initialized shutdown log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeAuth(\\\\\\\\\\\\\\\"Initialized authorization log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
sleep(0.25)\\\\\\\\\\\\\\\
if http then\\\\\\\\\\\\\\\
 log.writeBootLog(\\\\\\\\\\\\\\\"HTTP detection succeeded\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
else\\\\\\\\\\\\\\\
 log.writeBootLog(\\\\\\\\\\\\\\\"HTTP detection failed\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
sleep(0.5)\\\\\\\\\\\\\\\
shell.run(\\\\\\\\\\\\\\\"/etc/autorun\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Enumerating user assemblies...\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
kernel.loadUserAssemblies(true)\\\\\\\\\\\\\\\
sleep(0.25)\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Initiating security protocols\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"isReadOnly\\\\\\\\\\\\\\\"] = function(path)\\\\\\\\\\\\\\\
 local find1 = shell.resolve(path)\\\\\\\\\\\\\\\
 if string.find(find1, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return false\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return true\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find1 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find1 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return true\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldReadOnly(path)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"move\\\\\\\\\\\\\\\"] = function(path1, path2)\\\\\\\\\\\\\\\
 local find2 = shell.resolve(path1)\\\\\\\\\\\\\\\
 if string.find(find2, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return nil\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find2 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find2 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return nil\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldMove(path1, path2)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"delete\\\\\\\\\\\\\\\"] = function(path)\\\\\\\\\\\\\\\
 local find3 = shell.resolve(path)\\\\\\\\\\\\\\\
 if string.find(find3, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return nil\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find3 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find3 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return nil\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldDelete(path)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"http\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"get\\\\\\\\\\\\\\\"] = function(url, headers)\\\\\\\\\\\\\\\
 log.writeSecurity(\\\\\\\\\\\\\\\"Downloaded contents of \\\\\\\\\\\\\\\"..url)\\\\\\\\\\\\\\\
 return oldHttpGet(url, headers)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"error\\\\\\\\\\\\\\\"] = function(text, lvl)\\\\\\\\\\\\\\\
 local x = lvl or 2\\\\\\\\\\\\\\\
 local logger = fs.open(\\\\\\\\\\\\\\\"/etc/errorLog\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 logger.writeLine(tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"..text)\\\\\\\\\\\\\\\
 logger.close()\\\\\\\\\\\\\\\
 oldError(text, x or 1)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native\\\\\\\\\\\\\\\", {})\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.check\\\\\\\\\\\\\\\", oldReadOnly)\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.move\\\\\\\\\\\\\\\", oldMove)\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.delete\\\\\\\\\\\\\\\", oldDelete)\\\\\\\\\\\\\\\
rawset(http, \\\\\\\\\\\\\\\"_synchronise\\\\\\\\\\\\\\\", oldHttpGet)\\\\\\\\\\\\\\\
rawset(os, \\\\\\\\\\\\\\\"_exception\\\\\\\\\\\\\\\", oldError)\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Boot sequence stage 2 complete\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
local setupLines = {}\\\\\\\\\\\\\\\
setupLines.stageOne = {\\\\\\\\\\\\\\\"(Handling autorun files)\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"(Initializing security)\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"(Running authorization)\\\\\\\\\\\\\\\"}\\\\\\\\\\\\\\\
gui.clearScreen(colors.cyan)\\\\\\\\\\\\\\\
gui.drawImg(\\\\\\\\\\\\\\\"/boot/tesseract.img\\\\\\\\\\\\\\\", 8, 5)\\\\\\\\\\\\\\\
gui.printColoredTextLine(18, \\\\\\\\\\\\\\\"Tesseract boot sequence in progress...\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
sleep(2)\\\\\\\\\\\\\\\
annotateLoading(\\\\\\\\\\\\\\\"Booting Tesseract...\\\\\\\\\\\\\\\", setupLines.stageOne, 1.25)\\\\\\\\\\\\\\\
sleep(2)\\\\\\\\\\\\\\\
kernel.clear()\\\\\\\\\\\\\\\
shell.run(\\\\\\\\\\\\\\\"/etc/auth\\\\\\\\\\\\\\\")\\\\\\\"\\\",\\\
  \\\"F:tesseract-fastboot\\\",\\\
  \\\"\\\\\\\"local function annotateLoading(txt, array, delay)\\\\\\\\\\\\\\\
 for _, v in ipairs(array) do\\\\\\\\\\\\\\\
  gui.printColoredTextLine(18, txt..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v)\\\\\\\\\\\\\\\
  sleep(delay or 1.5)\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local oldReadOnly = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"isReadOnly\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldMove = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"move\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldDelete = _G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"delete\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldHttpGet = _G[\\\\\\\\\\\\\\\"http\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"get\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
local oldError = _G[\\\\\\\\\\\\\\\"error\\\\\\\\\\\\\\\"]\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Initialized system boot log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeSyslog(\\\\\\\\\\\\\\\"Initialized primary system log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeMessage(\\\\\\\\\\\\\\\"Initialized secondary system log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeSecurity(\\\\\\\\\\\\\\\"Initialized security/access log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeShutdown(\\\\\\\\\\\\\\\"Initialized shutdown log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeAuth(\\\\\\\\\\\\\\\"Initialized authorization log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
sleep(0.25)\\\\\\\\\\\\\\\
if http then\\\\\\\\\\\\\\\
 log.writeBootLog(\\\\\\\\\\\\\\\"HTTP detection succeeded\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
else\\\\\\\\\\\\\\\
 log.writeBootLog(\\\\\\\\\\\\\\\"HTTP detection failed\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
sleep(0.5)\\\\\\\\\\\\\\\
shell.run(\\\\\\\\\\\\\\\"/etc/autorun\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Enumerating user assemblies...\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
kernel.loadUserAssemblies(true)\\\\\\\\\\\\\\\
sleep(0.25)\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Initiating security protocols\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"isReadOnly\\\\\\\\\\\\\\\"] = function(path)\\\\\\\\\\\\\\\
 local find1 = shell.resolve(path)\\\\\\\\\\\\\\\
 if string.find(find1, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find1, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return false\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return true\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find1 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find1 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return true\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldReadOnly(path)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"move\\\\\\\\\\\\\\\"] = function(path1, path2)\\\\\\\\\\\\\\\
 local find2 = shell.resolve(path1)\\\\\\\\\\\\\\\
 if string.find(find2, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find2, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return nil\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find2 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find2 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return nil\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldMove(path1, path2)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"fs\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"delete\\\\\\\\\\\\\\\"] = function(path)\\\\\\\\\\\\\\\
 local find3 = shell.resolve(path)\\\\\\\\\\\\\\\
 if string.find(find3, \\\\\\\\\\\\\\\"boot\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"etc\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"bin\\\\\\\\\\\\\\\") or string.find(find3, \\\\\\\\\\\\\\\"sbin\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access system files!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if security.getSU() or _IDENTIFIER then\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Superuser access verified.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
   return nil\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 elseif find3 == \\\\\\\\\\\\\\\"startup\\\\\\\\\\\\\\\" or find3 == \\\\\\\\\\\\\\\"/startup\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to access bootloader!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  exception.throw(\\\\\\\\\\\\\\\"RestrictedOpsException\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return nil\\\\\\\\\\\\\\\
 end \\\\\\\\\\\\\\\
 return oldDelete(path)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"http\\\\\\\\\\\\\\\"][\\\\\\\\\\\\\\\"get\\\\\\\\\\\\\\\"] = function(url, headers)\\\\\\\\\\\\\\\
 log.writeSecurity(\\\\\\\\\\\\\\\"Downloaded contents of \\\\\\\\\\\\\\\"..url)\\\\\\\\\\\\\\\
 return oldHttpGet(url, headers)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
_G[\\\\\\\\\\\\\\\"error\\\\\\\\\\\\\\\"] = function(text, lvl)\\\\\\\\\\\\\\\
 local x = lvl or 2\\\\\\\\\\\\\\\
 local logger = fs.open(\\\\\\\\\\\\\\\"/etc/errorLog\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 logger.writeLine(tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"..text)\\\\\\\\\\\\\\\
 logger.close()\\\\\\\\\\\\\\\
 oldError(text, x or 1)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native\\\\\\\\\\\\\\\", {})\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.check\\\\\\\\\\\\\\\", oldReadOnly)\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.move\\\\\\\\\\\\\\\", oldMove)\\\\\\\\\\\\\\\
rawset(fs, \\\\\\\\\\\\\\\"_native.delete\\\\\\\\\\\\\\\", oldDelete)\\\\\\\\\\\\\\\
rawset(http, \\\\\\\\\\\\\\\"_synchronise\\\\\\\\\\\\\\\", oldHttpGet)\\\\\\\\\\\\\\\
rawset(os, \\\\\\\\\\\\\\\"_exception\\\\\\\\\\\\\\\", oldError)\\\\\\\\\\\\\\\
log.writeBootLog(\\\\\\\\\\\\\\\"Boot sequence stage 2 completee\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
kernel.clear()\\\\\\\\\\\\\\\
shell.run(\\\\\\\\\\\\\\\"/etc/auth\\\\\\\\\\\\\\\")\\\\\\\"\\\",\\\
}\",\
  \"F:tesseract.img\",\
  \"\\\"9999999999999999999999999999999999999\\\\\\\
9bbb9bbb9bbb9bbb9bbb9bb999b999bb9bbb9\\\\\\\
99b99b999b999b999b999b9b9b9b9b9999b99\\\\\\\
99b99bbb9bbb9bbb9bbb9bb99b9b9b9999b99\\\\\\\
99b99b99999b999b9b999b9b9bbb9b9999b99\\\\\\\
99b99bbb9bbb9bbb9bbb9b9b9b9b99bb99b99\\\\\\\
9999999999999999999999999999999999999\\\"\",\
}",
  "D:etc",
  "{\
  \"D:.backups\",\
  \"{}\",\
  \"F:auth\",\
  \"\\\"while true do\\\\\\\
 write(\\\\\\\"Username: \\\\\\\")\\\\\\\
 local input = read()\\\\\\\
 if fs.exists(\\\\\\\"/etc/passwd/\\\\\\\"..input..\\\\\\\".dat\\\\\\\") and not fs.isDir(\\\\\\\"/etc/passwd/\\\\\\\"..input..\\\\\\\".dat\\\\\\\") then\\\\\\\
  local pass = security.unpassbyte(input)\\\\\\\
  while true do\\\\\\\
   if kernel.secureInput(\\\\\\\"Password:\\\\\\\", pass) then\\\\\\\
    os.pullEvent = function()\\\\\\\
	 local eventData = { os.pullEventRaw( _sFilter ) }\\\\\\\
	 if eventData[1] == \\\\\\\"terminate\\\\\\\" then\\\\\\\
	  error( \\\\\\\"Terminated\\\\\\\", 0 )\\\\\\\
	 end\\\\\\\
	 return unpack( eventData )\\\\\\\
	end\\\\\\\
    kernel.clear()\\\\\\\
	rawset(_G, \\\\\\\"_activeUser\\\\\\\", input)\\\\\\\
	if fs.exists(\\\\\\\"/home/\\\\\\\".._G[\\\\\\\"_activeUser\\\\\\\"]..\\\\\\\"/autorun\\\\\\\") then\\\\\\\
	 shell.run(\\\\\\\"/home/\\\\\\\".._G[\\\\\\\"_activeUser\\\\\\\"]..\\\\\\\"/autorun\\\\\\\")\\\\\\\
	end\\\\\\\
	log.writeAuth(\\\\\\\"User \\\\\\\"..input..\\\\\\\" logged in\\\\\\\")\\\\\\\
	if input == \\\\\\\"root\\\\\\\" then\\\\\\\
	 log.writeSecurity(\\\\\\\"Superuser account is active\\\\\\\")\\\\\\\
	end\\\\\\\
    shell.run(\\\\\\\"/bin/sh\\\\\\\")\\\\\\\
	if security.getSU() then\\\\\\\
     gui.printAppWarning(\\\\\\\"kernel\\\\\\\", \\\\\\\"exiting into top-level shell\\\\\\\")\\\\\\\
     log.writeMessage(\\\\\\\"exiting into top-level shell\\\\\\\")\\\\\\\
	 break\\\\\\\
	end\\\\\\\
	kernel.shutdown(false)\\\\\\\
   end\\\\\\\
  end\\\\\\\
 end\\\\\\\
 if input == \\\\\\\"root\\\\\\\" and security.getSU() then\\\\\\\
  break\\\\\\\
 end\\\\\\\
end\\\"\",\
  \"F:autorun\",\
  \"\\\"local oldPath = shell.path()\\\\\\\
shell.setPath(oldPath..\\\\\\\":/bin:/sbin:/etc/script_util:/usr/bin:/usr/local/bin\\\\\\\")\\\\\\\
\\\\\\\
os.version = function()\\\\\\\
 return \\\\\\\"TESSERACT Alpha | Release Preview 1.0.0/#0095\\\\\\\"\\\\\\\
end\\\\\\\
\\\\\\\
local link = config.load(\\\\\\\"/etc/link.dat\\\\\\\")\\\\\\\
\\\\\\\
for k,v in pairs(link) do\\\\\\\
 shell.setAlias(k, v)\\\\\\\
end\\\"\",\
  \"D:config\",\
  \"{}\",\
  \"F:errorLog\",\
  \"\\\"207d:19:39 | Cannot serialize type function\\\\\\\
208d:6:38 | 1\\\"\",\
  \"D:kernel\",\
  \"{\\\
  \\\"D:libraries\\\",\\\
  \\\"{}\\\",\\\
}\",\
  \"D:lib\",\
  \"{\\\
  \\\"F:config\\\",\\\
  \\\"\\\\\\\"function load(path)\\\\\\\\\\\\\\\
 if fs.exists(path) and not fs.isDir(path) then\\\\\\\\\\\\\\\
  local lf = fs.open(path, \\\\\\\\\\\\\\\"r\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  local contents = lf.readAll()\\\\\\\\\\\\\\\
  lf.close()\\\\\\\\\\\\\\\
  return textutils.unserialize(contents)\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  return nil\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function save(cTable, path)\\\\\\\\\\\\\\\
 if fs.exists(path) then\\\\\\\\\\\\\\\
  if fs.isDir(path) then\\\\\\\\\\\\\\\
   return false\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 local sf = fs.open(path, \\\\\\\\\\\\\\\"w\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 sf.write(textutils.serialize(cTable))\\\\\\\\\\\\\\\
 sf.close()\\\\\\\\\\\\\\\
 return true\\\\\\\\\\\\\\\
end\\\\\\\"\\\",\\\
  \\\"F:exception\\\",\\\
  \\\"\\\\\\\"local instances = {}\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
instances.GenericException = function(text)\\\\\\\\\\\\\\\
 gui.printAppWarning(fs.getName(shell.getRunningProgram()), text)\\\\\\\\\\\\\\\
 log.writeSecurity(text) \\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
instances.RestrictedOpsException = function(a)\\\\\\\\\\\\\\\
 b = a or \\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
 gui.printAppWarning(\\\\\\\\\\\\\\\"kernel\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"attempt to perform restricted operations\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 log.writeSecurity(\\\\\\\\\\\\\\\"Attempt to perform restricted operations!\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 log.writeSecurity(\\\\\\\\\\\\\\\"Attempt blocked.\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
instances.SecurityException = function(path)\\\\\\\\\\\\\\\
 gui.printAppWarning(\\\\\\\\\\\\\\\"kernel\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"attempt to perform restricted operations\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 log.writeSecurity(_activeUser..\\\\\\\\\\\\\\\" attempted to open restricted file at \\\\\\\\\\\\\\\"..path)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function throw(exception, arg)\\\\\\\\\\\\\\\
 if instances[exception] then\\\\\\\\\\\\\\\
  instances[exception](arg)\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  instances.GenericException(\\\\\\\\\\\\\\\"no such exception\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\"\\\",\\\
  \\\"F:log\\\",\\\
  \\\"\\\\\\\"-- this is a compatibility file for supporting kernel-mode logging\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
writeSyslog = kernel.writeSyslog\\\\\\\\\\\\\\\
writeMessage = kernel.writeMessage\\\\\\\\\\\\\\\
writeSecurity = kernel.writeSecurity\\\\\\\\\\\\\\\
writeShutdown = kernel.writeShutdown\\\\\\\\\\\\\\\
writeAuth = kernel.writeAuth\\\\\\\\\\\\\\\
writeBootLog = kernel.writeBootLog\\\\\\\"\\\",\\\
  \\\"F:luaex\\\",\\\
  \\\"\\\\\\\"function stringToByteArray(str)\\\\\\\\\\\\\\\
 return string.byte(str, 1, str:len())\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function argsToTable(...)\\\\\\\\\\\\\\\
 return { ... }\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function stringFromByteArray(...)\\\\\\\\\\\\\\\
 return string.char(...)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function iterateFileLines(path)\\\\\\\\\\\\\\\
 local handle = fs.open(path, \\\\\\\\\\\\\\\"r\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 local commands = {}\\\\\\\\\\\\\\\
 local line = handle.readLine()\\\\\\\\\\\\\\\
 while line do\\\\\\\\\\\\\\\
  commands[#commands + 1] = line\\\\\\\\\\\\\\\
  line = handle.readLine()\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 handle.close()\\\\\\\\\\\\\\\
 return commands\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
local function string_separate(str)\\\\\\\\\\\\\\\
 local t = {}\\\\\\\\\\\\\\\
 for i in string.gmatch(str, \\\\\\\\\\\\\\\"[A-z]\\\\\\\\\\\\\\\") do\\\\\\\\\\\\\\\
  table.insert(t, i)\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 return t\\\\\\\\\\\\\\\
end\\\\\\\"\\\",\\\
  \\\"F:net\\\",\\\
  \\\"\\\\\\\"local isOnline = false\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function getHTTP(url)\\\\\\\\\\\\\\\
 local handlex = http.get(url)\\\\\\\\\\\\\\\
 local contents = handlex.readAll()\\\\\\\\\\\\\\\
 handlex.close()\\\\\\\\\\\\\\\
 return contents\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function openModems()\\\\\\\\\\\\\\\
    for n,sModem in ipairs( peripheral.getNames() ) do\\\\\\\\\\\\\\\
        if peripheral.getType( sModem ) == \\\\\\\\\\\\\\\"modem\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
            if not rednet.isOpen( sModem ) then\\\\\\\\\\\\\\\
                rednet.open( sModem )\\\\\\\\\\\\\\\
            end\\\\\\\\\\\\\\\
        end\\\\\\\\\\\\\\\
    end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function closeModems()\\\\\\\\\\\\\\\
    for n,sModem in ipairs( peripheral.getNames() ) do\\\\\\\\\\\\\\\
        if peripheral.getType( sModem ) == \\\\\\\\\\\\\\\"modem\\\\\\\\\\\\\\\" then\\\\\\\\\\\\\\\
            if rednet.isOpen( sModem ) then\\\\\\\\\\\\\\\
                rednet.close( sModem )\\\\\\\\\\\\\\\
            end\\\\\\\\\\\\\\\
        end\\\\\\\\\\\\\\\
    end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function getModemStatus(side)\\\\\\\\\\\\\\\
 gui.printAppInfo(\\\\\\\\\\\\\\\"net\\\\\\\\\\\\\\\", side .. \\\\\\\\\\\\\\\" modem status: \\\\\\\\\\\\\\\" .. tostring(rednet.isOpen(side)))\\\\\\\\\\\\\\\
 return rednet.isOpen(side)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
-- DNS self-hosting functions\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function setWorkstationStatus(state)\\\\\\\\\\\\\\\
 if state == true and isOnline == false then\\\\\\\\\\\\\\\
  local label = os.getComputerLabel() or \\\\\\\\\\\\\\\"Tesseract\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
  rednet.host(\\\\\\\\\\\\\\\"tesseract_dns\\\\\\\\\\\\\\\", tostring(os.getComputerID())..\\\\\\\\\\\\\\\"_\\\\\\\\\\\\\\\"..label)\\\\\\\\\\\\\\\
  isOnline = true\\\\\\\\\\\\\\\
  log.writeSyslog(\\\\\\\\\\\\\\\"Now susceptible for DNS lookup\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeMessage(\\\\\\\\\\\\\\\"Assigned DNS label \\\\\\\\\\\\\\\"..tostring(os.getComputerID())..\\\\\\\\\\\\\\\"_\\\\\\\\\\\\\\\"..label)\\\\\\\\\\\\\\\
 elseif state == false and isOnline == true then\\\\\\\\\\\\\\\
  local label = os.getComputerLabel or \\\\\\\\\\\\\\\"Tesseract\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
  rednet.host(\\\\\\\\\\\\\\\"tesseract_dns\\\\\\\\\\\\\\\", tostring(os.getComputerID())..\\\\\\\\\\\\\\\"_\\\\\\\\\\\\\\\"..label)\\\\\\\\\\\\\\\
  isOnline = false\\\\\\\\\\\\\\\
  log.writeSyslog(\\\\\\\\\\\\\\\"No longer susceptible for DNS lookup\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  log.writeMessage(\\\\\\\\\\\\\\\"De-assigned DNS label \\\\\\\\\\\\\\\"..tostring(os.getComputerID())..\\\\\\\\\\\\\\\"_\\\\\\\\\\\\\\\"..label)\\\\\\\\\\\\\\\
 elseif state == true and isOnline == true then\\\\\\\\\\\\\\\
  gui.printAppWarning(\\\\\\\\\\\\\\\"net\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"workstation already online\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 elseif state == false and isOnline == false then\\\\\\\\\\\\\\\
  gui.printAppWarning(\\\\\\\\\\\\\\\"net\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"workstation already offline\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  log.writeSyslog(\\\\\\\\\\\\\\\"RedNet interface error\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return nil, \\\\\\\\\\\\\\\"error in RNI, please consult developer\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function getWorkstationStatus()\\\\\\\\\\\\\\\
 return isOnline\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function findWorkstation(query)\\\\\\\\\\\\\\\
 if rednet.lookup(\\\\\\\\\\\\\\\"tesseract_dns\\\\\\\\\\\\\\\", query) ~= nil then\\\\\\\\\\\\\\\
  return true, rednet.lookup(\\\\\\\\\\\\\\\"tesseract_dns\\\\\\\\\\\\\\\", query)\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  return false, nil\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\"\\\",\\\
  \\\"F:search\\\",\\\
  \\\"\\\\\\\"function traverseKey(array, text)\\\\\\\\\\\\\\\
 for k,v in pairs(array) do\\\\\\\\\\\\\\\
  if v == text then\\\\\\\\\\\\\\\
   return true, k\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 return false, nil\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function traverseValue(array, text)\\\\\\\\\\\\\\\
 for k,v in pairs(array) do\\\\\\\\\\\\\\\
  if k == text then\\\\\\\\\\\\\\\
   return true, v\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 return false, nil\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function findKey(array, text)\\\\\\\\\\\\\\\
 for k,v in pairs(array) do\\\\\\\\\\\\\\\
  if k == text then\\\\\\\\\\\\\\\
   return true, k\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 return false, nil\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function findValue(array, text)\\\\\\\\\\\\\\\
 for k,v in pairs(array) do\\\\\\\\\\\\\\\
  if v == text then\\\\\\\\\\\\\\\
   return true, v\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 return false, nil\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function queryForKey(array, text)\\\\\\\\\\\\\\\
 for k,v in pairs(array) do\\\\\\\\\\\\\\\
  if string.find(k, text) then\\\\\\\\\\\\\\\
   return true, k\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 return false, nil\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function queryForValue(array, text)\\\\\\\\\\\\\\\
 for k,v in pairs(array) do\\\\\\\\\\\\\\\
  if string.find(v, text) then\\\\\\\\\\\\\\\
   return true, v\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 return false, nil\\\\\\\\\\\\\\\
end\\\\\\\"\\\",\\\
  \\\"F:security\\\",\\\
  \\\"\\\\\\\"local _IDENTIFIER = \\\\\\\\\\\\\\\"ac30527de6170b7d545bdc152f76237276537f2cf8eb7fe5bdb2a7627f48cec1\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function getSU()\\\\\\\\\\\\\\\
 if fs.exists(\\\\\\\\\\\\\\\"/etc/passwd/.shadow/\\\\\\\\\\\\\\\".._G[\\\\\\\\\\\\\\\"_activeUser\\\\\\\\\\\\\\\"]..\\\\\\\\\\\\\\\".usr\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  local ud = dofile(\\\\\\\\\\\\\\\"/etc/passwd/.shadow/\\\\\\\\\\\\\\\".._G[\\\\\\\\\\\\\\\"_activeUser\\\\\\\\\\\\\\\"]..\\\\\\\\\\\\\\\".usr\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  return ud.SU\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  return false\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function getID()\\\\\\\\\\\\\\\
 return _IDENTIFIER\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function getActiveUserStatus()\\\\\\\\\\\\\\\
 if fs.exists(\\\\\\\\\\\\\\\"/etc/passwd/.shadow/\\\\\\\\\\\\\\\".._G[\\\\\\\\\\\\\\\"_activeUser\\\\\\\\\\\\\\\"]..\\\\\\\\\\\\\\\".usr\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  local ud = dofile(\\\\\\\\\\\\\\\"/etc/passwd/.shadow/\\\\\\\\\\\\\\\".._G[\\\\\\\\\\\\\\\"_activeUser\\\\\\\\\\\\\\\"]..\\\\\\\\\\\\\\\".usr\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
  if ud.ID == getID() then\\\\\\\\\\\\\\\
   return true\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
  return false\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  return false\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function passbyte(username, str)\\\\\\\\\\\\\\\
 passTable = luaex.argsToTable(luaex.stringToByteArray(str))\\\\\\\\\\\\\\\
 if config.save(passTable, \\\\\\\\\\\\\\\"/etc/passwd/\\\\\\\\\\\\\\\"..username..\\\\\\\\\\\\\\\".dat\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  return true\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  return false\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function unpassbyte(username)\\\\\\\\\\\\\\\
 passTable = config.load(\\\\\\\\\\\\\\\"/etc/passwd/\\\\\\\\\\\\\\\"..username..\\\\\\\\\\\\\\\".dat\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 if passTable ~= nil then\\\\\\\\\\\\\\\
  return luaex.stringFromByteArray(unpack(passTable))\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\"\\\",\\\
  \\\"F:tpm\\\",\\\
  \\\"\\\\\\\"function getPaste(file, id, overwrite)\\\\\\\\\\\\\\\
 if overwrite and fs.exists(file) and string.find(file, \\\\\\\\\\\\\\\"system/\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
  if fs.exists(\\\\\\\\\\\\\\\"/etc/.backups/\\\\\\\\\\\\\\\"..file) then\\\\\\\\\\\\\\\
   fs.delete(\\\\\\\\\\\\\\\"/etc/.backups/\\\\\\\\\\\\\\\"..file)\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
  fs.copy(file, \\\\\\\\\\\\\\\"/etc/.backups/\\\\\\\\\\\\\\\"..file)\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
 return kernel.getFile(file, \\\\\\\\\\\\\\\"http://pastebin.com/raw/\\\\\\\\\\\\\\\"..id, overwrite)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function downloadAPI(filename, id)\\\\\\\\\\\\\\\
 return getPaste(\\\\\\\\\\\\\\\"/usr/local/lib/\\\\\\\\\\\\\\\"..filename, id, true)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function downloadBinary(filename, id)\\\\\\\\\\\\\\\
 return getPaste(\\\\\\\\\\\\\\\"/usr/local/bin/\\\\\\\\\\\\\\\"..filename, id, true)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function toPackageAPI(filename)\\\\\\\\\\\\\\\
 return \\\\\\\\\\\\\\\"/usr/local/lib/\\\\\\\\\\\\\\\"..filename\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
function toPackageBinary(filename)\\\\\\\\\\\\\\\
 return \\\\\\\\\\\\\\\"/usr/local/bin/\\\\\\\\\\\\\\\"..filename\\\\\\\\\\\\\\\
end\\\\\\\"\\\",\\\
}\",\
  \"F:link.dat\",\
  \"\\\"{[\\\\\\\"lua\\\\\\\"]=\\\\\\\"/bin/lsh\\\\\\\",[\\\\\\\"username\\\\\\\"]=\\\\\\\"/bin/uname\\\\\\\",[\\\\\\\"whoami\\\\\\\"]=\\\\\\\"/bin/uname\\\\\\\",[\\\\\\\"help\\\\\\\"]=\\\\\\\"/bin/man\\\\\\\",[\\\\\\\"shell\\\\\\\"]=\\\\\\\"/bin/sh\\\\\\\",[\\\\\\\"sh\\\\\\\"]=\\\\\\\"/bin/sh\\\\\\\",[\\\\\\\"shutdown\\\\\\\"]=\\\\\\\"/sbin/shutdown\\\\\\\",[\\\\\\\"reboot\\\\\\\"]=\\\\\\\"/sbin/reboot\\\\\\\",}\\\"\",\
  \"D:manuals\",\
  \"{\\\
  \\\"F:api-app\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Application API is deprecated since Warp Sierra\\\\\\\\\\\\\\\
and has been merged into the Tesseract kernel.\\\\\\\\\\\\\\\
This manual page will be removed soon.\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:api-config\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Configuration API deals with configuration\\\\\\\\\\\\\\\
files: it loads and saves tables into files.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
It has two functions:\\\\\\\\\\\\\\\
config.load(path)\\\\\\\\\\\\\\\
config.save(tableToSave, path)\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Configuration files are usually marked by the\\\\\\\\\\\\\\\
'.conf' extension.\\\\\\\"\\\",\\\
  \\\"F:api-custom\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The 'Custom API' is used to add functions and\\\\\\\\\\\\\\\
values to the runtime environment without much\\\\\\\\\\\\\\\
hard work ('man custom-api').\\\\\\\"\\\",\\\
  \\\"F:api-gui\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Graphical User Interface API is responsible\\\\\\\\\\\\\\\
for all the colorful text and interface elements\\\\\\\\\\\\\\\
of Tesseract and has the following functions:\\\\\\\\\\\\\\\
button(txt, x1, x2, y)\\\\\\\\\\\\\\\
counter(txt, y)\\\\\\\\\\\\\\\
drawProgress(txt, y) / drawProgressAlt()\\\\\\\\\\\\\\\
printBootInfo(i)\\\\\\\\\\\\\\\
printBootWarning(w)\\\\\\\\\\\\\\\
printBootSuccess(s)\\\\\\\\\\\\\\\
printAppInfo(header, msg)\\\\\\\\\\\\\\\
printAppWarning(header, msg)\\\\\\\\\\\\\\\
printAppSuccess(header, msg)\\\\\\\\\\\\\\\
request(text)\\\\\\\\\\\\\\\
drawImg(path, x. y)\\\\\\\\\\\\\\\
printColoredTextLine(y, txt, bg, fg)\\\\\\\\\\\\\\\
clearScreen(bgColor)\\\\\\\"\\\",\\\
  \\\"F:api-kernel\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Kernel API is the one that backs the whole\\\\\\\\\\\\\\\
Operating System. It provides wrappers for some\\\\\\\\\\\\\\\
in-built functions, and is responsible for\\\\\\\\\\\\\\\
error report generation.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Functions in the Kernel API:\\\\\\\\\\\\\\\
credits()\\\\\\\\\\\\\\\
clear()\\\\\\\\\\\\\\\
crashReport(path, description)\\\\\\\\\\\\\\\
import(file) (A safe os.loadAPI)\\\\\\\\\\\\\\\
require(file) (A primitive require function)\\\\\\\\\\\\\\\
APIHook(api)\\\\\\\\\\\\\\\
printFile(file)\\\\\\\\\\\\\\\
secureInput(invite, definition)\\\\\\\\\\\\\\\
shutdown(removeVar) / reboot(removeVar)\\\\\\\\\\\\\\\
findManual(name) (Find a manual file path)\\\\\\\\\\\\\\\
The Logging API ('man api-log') functions\\\\\\\"\\\",\\\
  \\\"F:api-log\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Logging API serves as a log file\\\\\\\\\\\\\\\
handler.\\\\\\\\\\\\\\\
Logs are viewed through dmesg ('man dmesg')\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Functions with corresponding files:\\\\\\\\\\\\\\\
writeAuth(msg)      ->  /var/log/auth\\\\\\\\\\\\\\\
writeBootLog(msg)   ->  /var/log/boot\\\\\\\\\\\\\\\
writeMessage(msg)   ->  /var/log/messages\\\\\\\\\\\\\\\
writeSyslog(msg)    ->  /var/log/syslog\\\\\\\\\\\\\\\
writeSecurity(msg)  ->  /var/log/security\\\\\\\\\\\\\\\
writeShutdown(msg)  ->  /var/log/shutdown\\\\\\\"\\\",\\\
  \\\"F:api-luaex\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The LuaEx API is used to add new miscellaneous\\\\\\\\\\\\\\\
features to the runtime environment.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Functions:\\\\\\\\\\\\\\\
stringToByteArray(str)\\\\\\\\\\\\\\\
argsToTable(...)\\\\\\\\\\\\\\\
stringFromByteArray(byteArrayTable)\\\\\\\"\\\",\\\
  \\\"F:api-manual\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Manual API is deprecated since Release 1.0\\\\\\\\\\\\\\\
and has been merged into the Tesseract kernel.\\\\\\\\\\\\\\\
This manual page will be removed soon.\\\\\\\"\\\",\\\
  \\\"F:api-search\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Search API simplifies searching in key-value\\\\\\\\\\\\\\\
arrays.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Functions:\\\\\\\\\\\\\\\
traverseKey(table, text)\\\\\\\\\\\\\\\
traverseValue(table, text)\\\\\\\\\\\\\\\
findKey(table, text)\\\\\\\\\\\\\\\
findValue(table, text)\\\\\\\"\\\",\\\
  \\\"F:api-security\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Security API serves as a credential handler,\\\\\\\\\\\\\\\
and is responsible for user creation and\\\\\\\\\\\\\\\
identification.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Functions:\\\\\\\\\\\\\\\
passbyte(username, password)\\\\\\\\\\\\\\\
unpassbyte(username)\\\\\\\\\\\\\\\
getSU()\\\\\\\"\\\",\\\
  \\\"F:api-tpm\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Tesseract Package Management API is used to\\\\\\\\\\\\\\\
simplify Pastebin handling and file downloads.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Functions:\\\\\\\\\\\\\\\
getPaste(file, id, overwrite)\\\\\\\\\\\\\\\
downloadAPI(file, id) / downloadBinary(file, id)\\\\\\\\\\\\\\\
toPackageAPI(filename) / toPackageBinary(filename)\\\\\\\"\\\",\\\
  \\\"F:archiver\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
archiver <...> [...]\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Required: mode (zip/unzip)\\\\\\\\\\\\\\\
          directory to zip/archive to unzip\\\\\\\\\\\\\\\
          archive file name/path to unzip\\\\\\\\\\\\\\\
Modes: zip (creates an archive)\\\\\\\\\\\\\\\
       unzip (unpacks an archive)\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
If using the zip mode you can specify two\\\\\\\\\\\\\\\
directories the archiver will skip after\\\\\\\\\\\\\\\
the required parameters.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
(c) 1Ridav.\\\\\\\\\\\\\\\
This is the only third-party program that\\\\\\\\\\\\\\\
Tesseract is using. It is, however,\\\\\\\\\\\\\\\
not a required part of the system.\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:auth\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The authorization system is one of the Tesseract\\\\\\\\\\\\\\\
security measures.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Credentials are handled with optimal security.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Each user has a home directory (/home/<username>)\\\\\\\\\\\\\\\
and a credentials identifier used to determine\\\\\\\\\\\\\\\
the user's privileges.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
See 'man usrutils' for account management programs.\\\\\\\"\\\",\\\
  \\\"F:boot-sequence\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Tesseract Boot Sequence consists of 4 steps:\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
 1 - The boot sequence is initiated.\\\\\\\\\\\\\\\
     Tesseract Boot Loader is launched and APIs\\\\\\\\\\\\\\\
     are loaded into the global environment.\\\\\\\\\\\\\\\
     \\\\\\\\\\\\\\\
 2 - The boot loader handles control to the\\\\\\\\\\\\\\\
     preferred bootloader record that executes\\\\\\\\\\\\\\\
     high-level routines (More: 'man custom-boot').\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
Assuming that the user prefers the default record:\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
 3 - Autorun files are handled, and all the code\\\\\\\\\\\\\\\
     inside of them is executed.\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
 4 - The Tesseract shell is launched.\\\\\\\"\\\",\\\
  \\\"F:categories\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
Some manuals belong to categories.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Here they are:\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
 api - Tesseract APIs\\\\\\\\\\\\\\\
 custom - customization\\\\\\\"\\\",\\\
  \\\"F:changelog\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
Build 0100 | Release v1.0 changelog:\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
! URGENT bug fixes!\\\\\\\\\\\\\\\
+ Added Lua error interception\\\\\\\\\\\\\\\
+ Added scripting\\\\\\\\\\\\\\\
* Huge tweaks to kernel and bootloader\\\\\\\\\\\\\\\
* Updated the GUI and LuaEx APIs\\\\\\\\\\\\\\\
* Integrated the Manual API into the kernel\\\\\\\\\\\\\\\
- Removed complex applications\\\\\\\"\\\",\\\
  \\\"F:config\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
Tesseract Configuration Files are handled by the\\\\\\\\\\\\\\\
Configuration API (man api-config). They are used\\\\\\\\\\\\\\\
to write easily accessible data to disk and access\\\\\\\\\\\\\\\
it when necessary.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Actually, they are just serialized Lua tables.\\\\\\\"\\\",\\\
  \\\"F:convert\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
convert <path>\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Converts an API-like configuration file to a\\\\\\\\\\\\\\\
serializable .conf/.dat file. Does not assign\\\\\\\\\\\\\\\
extension automatically.\\\\\\\"\\\",\\\
  \\\"F:coreutils\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
As the GNU/Linux systems, Tesseract also has its\\\\\\\\\\\\\\\
own coreutils package.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
 cat <file> - prints out a file\\\\\\\\\\\\\\\
 credits - prints out credits\\\\\\\\\\\\\\\
 dmesg (...) - displays logs ('man dmesg')\\\\\\\\\\\\\\\
 df <size> - displays filesystem stats ('man df')\\\\\\\\\\\\\\\
 man <manual page> - displays help ('man man')\\\\\\\\\\\\\\\
 scp <path> - copies a file to /home\\\\\\\\\\\\\\\
 shell - Tesseract shell\\\\\\\\\\\\\\\
 shutdown - performs shutdown\\\\\\\\\\\\\\\
 systeminfo (...) - shows stats ('man systeminfo')\\\\\\\\\\\\\\\
 tty - displays terminal size\\\\\\\\\\\\\\\
 \\\\\\\"\\\",\\\
  \\\"F:credits\\\",\\\
  \\\"\\\\\\\"Tesseract Operating System (Technical Preview)\\\\\\\\\\\\\\\
Made by\\\\\\\\\\\\\\\
 - minebuild02 (Head Developer)\\\\\\\\\\\\\\\
 - MasatoBaito (Assistant Developer)\\\\\\\\\\\\\\\
Special thanks to:\\\\\\\\\\\\\\\
 - 1Ridav (Developer of the DCC Archiver)\\\\\\\\\\\\\\\
 - Luca_S (Developer of the script parser base)\\\\\\\\\\\\\\\
Powered by original code.\\\\\\\\\\\\\\\
Licensed under the MIT License, subject to change.\\\\\\\"\\\",\\\
  \\\"F:custom\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
'custom-boot': Customizing the boot sequence\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
'custom-build': Building your own Tesseract OS\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
'custom-tpm': Creating your own package.dat\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
'custom-script': Automating tasks\\\\\\\"\\\",\\\
  \\\"F:custom-autorun\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
User autorun files can be used to perform various\\\\\\\\\\\\\\\
boot actions while not altering any boot sequence\\\\\\\\\\\\\\\
mechanisms.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
This should not be confused with the system autorun\\\\\\\\\\\\\\\
file ('/system/autorun'), that is used to perform\\\\\\\\\\\\\\\
post-boot initialization actions.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
User autorun files are located in\\\\\\\\\\\\\\\
/home/<username>/autorun\\\\\\\"\\\",\\\
  \\\"F:custom-boot\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
You can customize the boot sequence of Tesseract\\\\\\\\\\\\\\\
in two different ways:\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
  1. Writing a user autorun file (/home/autorun)\\\\\\\\\\\\\\\
    \\\\\\\\\\\\\\\
    User autorun files are good if you're not\\\\\\\\\\\\\\\
    too much of a professional. You can load\\\\\\\\\\\\\\\
    extra APIs or perform other actions.\\\\\\\\\\\\\\\
    More about user autorun files can be found\\\\\\\\\\\\\\\
    at 'man custom-autorun'.\\\\\\\\\\\\\\\
    \\\\\\\\\\\\\\\
  2. Writing a custom bootloader\\\\\\\\\\\\\\\
  \\\\\\\\\\\\\\\
    Information about custom bootloaders can\\\\\\\\\\\\\\\
    be found at 'man custom-bootloaders'\\\\\\\"\\\",\\\
  \\\"F:custom-bootloaders\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
In Tesseract, bootloader records are files that\\\\\\\\\\\\\\\
regulate the boot order of the operating system,\\\\\\\\\\\\\\\
responsible for the low-level system routines.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Writing a bootloader record requires a lot of\\\\\\\\\\\\\\\
experience in Lua programming. \\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Tesseract's standard bootloader record is located\\\\\\\\\\\\\\\
in '/boot/loaders/tesseract'. It is strongly\\\\\\\\\\\\\\\
recommended not to touch it.\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:custom-build\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
You can build your own Tesseract distribution,\\\\\\\\\\\\\\\
assuming that you have the system requirements:\\\\\\\\\\\\\\\
 - 1Ridav's Archiver must be present on your\\\\\\\\\\\\\\\
   system and the receiver's system\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
Run these commands in the shell:\\\\\\\\\\\\\\\
archiver zip / <name> rom <build directory>\\\\\\\\\\\\\\\
mv <name>.arch <build directory>\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
To install, run this command:\\\\\\\\\\\\\\\
<archiver path> unzip <name>.arch /\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Alternatively, you can download the\\\\\\\\\\\\\\\
'tesseract-buildtools' package and type 'buildtool'\\\\\\\\\\\\\\\
in the console - it will automatically build a\\\\\\\\\\\\\\\
system image.\\\\\\\"\\\",\\\
  \\\"F:custom-script\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
A Tesseract script file is actually a bunch of\\\\\\\\\\\\\\\
strings representing commands and executables.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
An example script is provided at the path\\\\\\\\\\\\\\\
'/system/demos/script.tsf'. Note that the\\\\\\\\\\\\\\\
header is VERY necessary, as without it the\\\\\\\\\\\\\\\
script parser will not be able to recognize\\\\\\\\\\\\\\\
the code.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Useful commands:\\\\\\\\\\\\\\\
@/scomment - comment out strings\\\\\\\\\\\\\\\
sdelay <seconds> - delay execution for set time\\\\\\\\\\\\\\\
secho [text] - output text/newline to console\\\\\\\"\\\",\\\
  \\\"F:custom-tpm\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
Before Warp 5, building your own package.dat file\\\\\\\\\\\\\\\
wasn't that hard, but with the new update bringing\\\\\\\\\\\\\\\
in dependency handling, the format has changed.\\\\\\\\\\\\\\\
Basically, the package.dat file is a complex table:\\\\\\\\\\\\\\\
{\\\\\\\\\\\\\\\
 package_name = {         -- The root structure ID\\\\\\\\\\\\\\\
  apis = {                -- Files put in /usr/api\\\\\\\\\\\\\\\
   apione = \\\\\\\\\\\\\\\"paste123\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
   apitwo = \\\\\\\\\\\\\\\"pastebin\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
  },\\\\\\\\\\\\\\\
  bins = {                -- Files put in /usr/bin\\\\\\\\\\\\\\\
   binone = \\\\\\\\\\\\\\\"pasted00\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
  },\\\\\\\\\\\\\\\
  name = \\\\\\\\\\\\\\\"simplepackage\\\\\\\\\\\\\\\", -- Package ID (equal to\\\\\\\\\\\\\\\
 },                          package_name)\\\\\\\\\\\\\\\
} (or ...)\\\\\\\"\\\",\\\
  \\\"F:demos\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
Demonstration, or fake programs are used to\\\\\\\\\\\\\\\
demonstrate various functions of Lua, CC APIs\\\\\\\\\\\\\\\
and Tesseract itself. Most of the Demonstration\\\\\\\\\\\\\\\
programs are part of Project Hacknet.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
hips-latest:  Counting down with timers\\\\\\\\\\\\\\\
nmap:         Fake network filesystem;\\\\\\\\\\\\\\\
              App message display\\\\\\\\\\\\\\\
winsetup:     GUI testing\\\\\\\\\\\\\\\
              \\\\\\\\\\\\\\\
nmap is a very special program because it was\\\\\\\\\\\\\\\
designed to be the core of Project Hacknet,\\\\\\\\\\\\\\\
the program that creates a fake network. It has\\\\\\\\\\\\\\\
its own manual page - see 'man nmap'\\\\\\\"\\\",\\\
  \\\"F:df\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
df <size>\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Displays the current filesystem information.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Without the size specified, the program only\\\\\\\\\\\\\\\
displays the filesystem type.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Size can be specified in bytes (-sB) or kilobytes\\\\\\\\\\\\\\\
(-sKB). With the size specified, the program also\\\\\\\\\\\\\\\
displays the current directory's size and free\\\\\\\\\\\\\\\
space.\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:dmesg\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
dmesg <log file name | -l/--list>\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Displays log files. -l/--list displays a list of\\\\\\\\\\\\\\\
them.\\\\\\\"\\\",\\\
  \\\"F:extensions\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
Here is the extension list:\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
.arch - DCC Archive ('man archiver')\\\\\\\\\\\\\\\
.conf - Tesseract Configuration File ('man config')\\\\\\\\\\\\\\\
.dat - Data file, contains unserializable data\\\\\\\\\\\\\\\
.tsf - Tesseract Script File ('man script')\\\\\\\\\\\\\\\
.usr - Tesseract User Data\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:firststeps\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
Welcome to Tesseract, my first operating system\\\\\\\\\\\\\\\
that got publicly released.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
You might not be familiar with it's mechanics,\\\\\\\\\\\\\\\
but I assure you that this operating system is\\\\\\\\\\\\\\\
a result of a great collaboration effort of two\\\\\\\\\\\\\\\
people, me and my friend MasatoBaito.\\\\\\\\\\\\\\\
I hope you enjoy using the system, if you have\\\\\\\\\\\\\\\
any questions, use the 'manpages' command to\\\\\\\\\\\\\\\
display a list of topics, then type 'man <topic>'\\\\\\\\\\\\\\\
to read the appropriate manuals. If you didn't find\\\\\\\\\\\\\\\
the answer - feel free to contact me via CC Forums.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Sincerely,\\\\\\\\\\\\\\\
minebuild02, Head Developer of Tesseract\\\\\\\"\\\",\\\
  \\\"F:man\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
man <man page> | manpages\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
The Manual Browser (man) is the Tesseract's help\\\\\\\\\\\\\\\
program. It is modeled after Debian's man,\\\\\\\\\\\\\\\
the documentation browser.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Typing manpages in the console displays a list\\\\\\\\\\\\\\\
of the available manual pages.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Also, you are viewing a man about man inside a man.\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:manedit\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
manedit <file>\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
manedit is an alias for the built-in editor\\\\\\\\\\\\\\\
program that is used for editing manual pages.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
It is actually the SAME program as 'edit'.\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:nmap\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
nmap [digits 1,2,3,4] [DNS record]\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Scans the network for terminals with open ports.\\\\\\\\\\\\\\\
If digits 1-4 are specified, scans for the\\\\\\\\\\\\\\\
corresponding IP address.\\\\\\\\\\\\\\\
If a DNS record is specified, uses it to register\\\\\\\\\\\\\\\
the terminal.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Be advised - it is a demonstration program.\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:script\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
script <file path>\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Launches a Tesseract script file.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
See 'man custom-script' for the specification.\\\\\\\\\\\\\\\
Scripts respect local security, and will launch\\\\\\\\\\\\\\\
specified applications that may error when not\\\\\\\\\\\\\\\
provided with superuser privileges.\\\\\\\"\\\",\\\
  \\\"F:shell\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
shell [program]\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
The Tesseract shell doesn't differ from the\\\\\\\\\\\\\\\
built-in one much. What it offers is a color\\\\\\\\\\\\\\\
scheme and username display. Filesystem type\\\\\\\\\\\\\\\
is now displayed by the df utility ('man df').\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Also, a new function was added to the Shell API -\\\\\\\\\\\\\\\
shell.executeScript(path), which executes a script\\\\\\\\\\\\\\\
on the provided path ('man script')\\\\\\\"\\\",\\\
  \\\"F:shutdown\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
shutdown [params]\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Executes shutdown procedure.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Parameters:\\\\\\\\\\\\\\\
-r/--reboot:      Restart instead of shutting down\\\\\\\\\\\\\\\
-i/--immediate:   No software callbacks, halt NOW\\\\\\\\\\\\\\\
-d/--delete-temp: Remove temporary files\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
By default, keeps temporary files and executes\\\\\\\\\\\\\\\
shutdown with software callbacks.\\\\\\\"\\\",\\\
  \\\"F:superuser\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
 Warp 4 added Linux-like superuser capabilities.\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
 Superuser privileges are by default granted to\\\\\\\\\\\\\\\
 the 'root' user.\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
 Superuser privileges are REQUIRED to:\\\\\\\\\\\\\\\
  \\\\\\\\\\\\\\\
  Add/change/remove user records;\\\\\\\\\\\\\\\
  Install TPM packages/complex applications;\\\\\\\\\\\\\\\
  Edit manual pages;\\\\\\\\\\\\\\\
  Edit boot records;\\\\\\\\\\\\\\\
  Edit system files\\\\\\\"\\\",\\\
  \\\"F:systeminfo\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
systeminfo <arguments>\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Displays system information.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Possible arguments:\\\\\\\\\\\\\\\
--os-version:    Displays OS version\\\\\\\\\\\\\\\
--shell-path:    Displays shell path\\\\\\\\\\\\\\\
--computer-info  Displays ID and label\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:tpm\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
The Tesseract Package Manager is similar to\\\\\\\\\\\\\\\
Linux-based operating systems' package managers.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
The repository data is stored in the\\\\\\\\\\\\\\\
'/system/data/package.dat' file.\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
Programs that compose the TPM are:\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
tpm-install <package>:  Install a package\\\\\\\\\\\\\\\
tpm-list <listing>:     List available packages\\\\\\\\\\\\\\\
tpm-recache:            Redownload package.dat\\\\\\\\\\\\\\\
tpm-remove <package>:   Remove a package\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
The tpm-list utility accepts a listing type as a\\\\\\\\\\\\\\\
parameter. You can list available packages\\\\\\\\\\\\\\\
('available') or installed ones ('installed').\\\\\\\"\\\",\\\
  \\\"F:usrutils\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
 mkusr <username> <password>\\\\\\\\\\\\\\\
 Creates a new user record.\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
 passwd <username> <password>\\\\\\\\\\\\\\\
 Changes a user's password.\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
 rmusr <username>\\\\\\\\\\\\\\\
 Removes a user record.\\\\\\\\\\\\\\\
 \\\\\\\"\\\",\\\
  \\\"F:versioning\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
Developer Build - regular build snapshot\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
 v v v\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
Warp 1-5 - public development preview\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
 v v v\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
Warp Sierra - technical pre-release\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
 v v v\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
Pre-release\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
 v v v\\\\\\\\\\\\\\\
 \\\\\\\\\\\\\\\
Release\\\\\\\"\\\",\\\
  \\\"F:versions\\\",\\\
  \\\"\\\\\\\"\\\\\\\\\\\\\\\
 0019: First developer build known, basic\\\\\\\\\\\\\\\
       system outline\\\\\\\\\\\\\\\
 0020: Some additions were implemented\\\\\\\\\\\\\\\
 0031: Tesseract starts looking modern-day,\\\\\\\\\\\\\\\
       manuals implemented along with\\\\\\\\\\\\\\\
       complex applications\\\\\\\\\\\\\\\
 0034: Manuals refined, demos organized,\\\\\\\\\\\\\\\
       utilities added\\\\\\\\\\\\\\\
 0038: 2 new APIs added, df bundled along with\\\\\\\\\\\\\\\
       SHA1\\\\\\\\\\\\\\\
 0040: Multiple changes, kernel and boot\\\\\\\\\\\\\\\
       sequence starting to change\\\\\\\\\\\\\\\
 0042: Redundancy added to bootloader, custom\\\\\\\\\\\\\\\
       records made possible\\\\\\\\\\\\\\\
 0046: First technical pre-release (Warp 1)\\\\\\\"\\\",\\\
}\",\
  \"D:passwd\",\
  \"{\\\
  \\\"D:.shadow\\\",\\\
  \\\"{\\\\\\\
  \\\\\\\"F:lsh.usr\\\\\\\",\\\\\\\
  \\\\\\\"\\\\\\\\\\\\\\\"local userdata = {}\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
userdata.SU = true\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
userdata.ID = security.getID()\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
userdata.shell = \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"/bin/lsh\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
return userdata\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\"\\\\\\\",\\\\\\\
  \\\\\\\"F:root.usr\\\\\\\",\\\\\\\
  \\\\\\\"\\\\\\\\\\\\\\\"local userdata = {}\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
userdata.SU = true\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
userdata.ID = \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
userdata.shell = \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"/bin/sh\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
return userdata\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\"\\\\\\\",\\\\\\\
}\\\",\\\
  \\\"F:lsh.dat\\\",\\\
  \\\"\\\\\\\"{\\\\\\\\\\\\\\\
  116,\\\\\\\\\\\\\\\
  111,\\\\\\\\\\\\\\\
  111,\\\\\\\\\\\\\\\
  114,\\\\\\\\\\\\\\\
}\\\\\\\"\\\",\\\
  \\\"F:root.dat\\\",\\\
  \\\"\\\\\\\"{\\\\\\\\\\\\\\\
  114,\\\\\\\\\\\\\\\
  111,\\\\\\\\\\\\\\\
  111,\\\\\\\\\\\\\\\
  116,\\\\\\\\\\\\\\\
}\\\\\\\"\\\",\\\
  \\\"F:user.dat\\\",\\\
  \\\"\\\\\\\"{\\\\\\\\\\\\\\\
  117,\\\\\\\\\\\\\\\
  115,\\\\\\\\\\\\\\\
  101,\\\\\\\\\\\\\\\
  114,\\\\\\\\\\\\\\\
}\\\\\\\"\\\",\\\
}\",\
  \"D:scripts\",\
  \"{\\\
  \\\"F:tpm-recache.tsf\\\",\\\
  \\\"\\\\\\\"@ @ !! TESSERACT SCRIPT HEADER\\\\\\\\\\\\\\\
@ This script performs recaching of TPM repo data\\\\\\\\\\\\\\\
error local TPM repository data corrupt\\\\\\\\\\\\\\\
slog_syslog reinitializing local TPM data\\\\\\\\\\\\\\\
tpm-repair\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
}\",\
  \"D:script_util\",\
  \"{\\\
  \\\"F:@\\\",\\\
  \\\"\\\\\\\"-- script comment exec\\\\\\\"\\\",\\\
  \\\"F:error\\\",\\\
  \\\"\\\\\\\"local logger = fs.open(\\\\\\\\\\\\\\\"/etc/errorLog\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
local tArgs = {...}\\\\\\\\\\\\\\\
local logstr = tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
for k,v in ipairs(tArgs) do\\\\\\\\\\\\\\\
 if k==1 then\\\\\\\\\\\\\\\
  logstr = logstr..v\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  logstr = logstr..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
logger.writeLine(logstr)\\\\\\\\\\\\\\\
logger.close()\\\\\\\"\\\",\\\
  \\\"F:scomment\\\",\\\
  \\\"\\\\\\\"-- script comment exec\\\\\\\"\\\",\\\
  \\\"F:sdelay\\\",\\\
  \\\"\\\\\\\"local tArgs = {...}\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
if #tArgs >= 1 then\\\\\\\\\\\\\\\
 sleep(tonumber(tArgs[1]))\\\\\\\\\\\\\\\
else\\\\\\\\\\\\\\\
 sleep(1)\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\"\\\",\\\
  \\\"F:secho\\\",\\\
  \\\"\\\\\\\"local tArgs = {...}\\\\\\\\\\\\\\\
for k,v in ipairs(tArgs) do\\\\\\\\\\\\\\\
 if k==1 then\\\\\\\\\\\\\\\
  write(tostring(v))\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  write(\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..tostring(v))\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
write(\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\n\\\\\\\\\\\\\\\")\\\\\\\"\\\",\\\
  \\\"F:slog_auth\\\",\\\
  \\\"\\\\\\\"if not fs.isDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\") and not fs.exists(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") and not fs.isDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local logger = fs.open(\\\\\\\\\\\\\\\"/var/log/auth\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
local tArgs = {...}\\\\\\\\\\\\\\\
local logstr = tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
for k,v in ipairs(tArgs) do\\\\\\\\\\\\\\\
 if k==1 then\\\\\\\\\\\\\\\
  logstr = logstr..v\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  logstr = logstr..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
logger.writeLine(logstr)\\\\\\\\\\\\\\\
logger.close()\\\\\\\"\\\",\\\
  \\\"F:slog_boot\\\",\\\
  \\\"\\\\\\\"if not fs.isDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\") and not fs.exists(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") and not fs.isDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local logger = fs.open(\\\\\\\\\\\\\\\"/var/log/boot\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
local tArgs = {...}\\\\\\\\\\\\\\\
local logstr = tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
for k,v in ipairs(tArgs) do\\\\\\\\\\\\\\\
 if k==1 then\\\\\\\\\\\\\\\
  logstr = logstr..v\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  logstr = logstr..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
logger.writeLine(logstr)\\\\\\\\\\\\\\\
logger.close()\\\\\\\"\\\",\\\
  \\\"F:slog_message\\\",\\\
  \\\"\\\\\\\"if not fs.isDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\") and not fs.exists(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") and not fs.isDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local logger = fs.open(\\\\\\\\\\\\\\\"/var/log/messages\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
local tArgs = {...}\\\\\\\\\\\\\\\
local logstr = tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
for k,v in ipairs(tArgs) do\\\\\\\\\\\\\\\
 if k==1 then\\\\\\\\\\\\\\\
  logstr = logstr..v\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  logstr = logstr..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
logger.writeLine(logstr)\\\\\\\\\\\\\\\
logger.close()\\\\\\\"\\\",\\\
  \\\"F:slog_security\\\",\\\
  \\\"\\\\\\\"if not fs.isDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\") and not fs.exists(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") and not fs.isDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local logger = fs.open(\\\\\\\\\\\\\\\"/var/log/security\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
local tArgs = {...}\\\\\\\\\\\\\\\
local logstr = tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
for k,v in ipairs(tArgs) do\\\\\\\\\\\\\\\
 if k==1 then\\\\\\\\\\\\\\\
  logstr = logstr..v\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  logstr = logstr..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
logger.writeLine(logstr)\\\\\\\\\\\\\\\
logger.close()\\\\\\\"\\\",\\\
  \\\"F:slog_shutdown\\\",\\\
  \\\"\\\\\\\"if not fs.isDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\") and not fs.exists(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") and not fs.isDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local logger = fs.open(\\\\\\\\\\\\\\\"/var/log/shutdown\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
local tArgs = {...}\\\\\\\\\\\\\\\
local logstr = tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
for k,v in ipairs(tArgs) do\\\\\\\\\\\\\\\
 if k==1 then\\\\\\\\\\\\\\\
  logstr = logstr..v\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  logstr = logstr..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
logger.writeLine(logstr)\\\\\\\\\\\\\\\
logger.close()\\\\\\\"\\\",\\\
  \\\"F:slog_syslog\\\",\\\
  \\\"\\\\\\\"if not fs.isDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\") and not fs.exists(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") and not fs.isDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/var/log\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local logger = fs.open(\\\\\\\\\\\\\\\"/var/log/syslog\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"a\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
local tArgs = {...}\\\\\\\\\\\\\\\
local logstr = tostring(os.day())..\\\\\\\\\\\\\\\"d:\\\\\\\\\\\\\\\"..textutils.formatTime(os.time(), true)..\\\\\\\\\\\\\\\" | \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\
for k,v in ipairs(tArgs) do\\\\\\\\\\\\\\\
 if k==1 then\\\\\\\\\\\\\\\
  logstr = logstr..v\\\\\\\\\\\\\\\
 else\\\\\\\\\\\\\\\
  logstr = logstr..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
logger.writeLine(logstr)\\\\\\\\\\\\\\\
logger.close()\\\\\\\"\\\",\\\
}\",\
  \"F:system\",\
  \"\\\"enableComplexApps = true\\\\\\\
enablePackageManagement = true\\\\\\\
enableHTTPAccess = true\\\"\",\
  \"D:tpm\",\
  \"{\\\
  \\\"F:package.dat\\\",\\\
  \\\"\\\\\\\"{\\\\\\\\\\\\\\\
  [\\\\\\\\\\\\\\\"tesseract-buildtools\\\\\\\\\\\\\\\"] = {\\\\\\\\\\\\\\\
    name = \\\\\\\\\\\\\\\"tesseract-buildtools\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
    bins = {\\\\\\\\\\\\\\\
      buildtool = \\\\\\\\\\\\\\\"7c4UbxNw\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
    },\\\\\\\\\\\\\\\
   apis = {},\\\\\\\\\\\\\\\
  },\\\\\\\\\\\\\\\
  sketch = {\\\\\\\\\\\\\\\
    name = \\\\\\\\\\\\\\\"sketch\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
    bins = {\\\\\\\\\\\\\\\
      sketch = \\\\\\\\\\\\\\\"Mm5hd97E\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
    },\\\\\\\\\\\\\\\
   apis = {},\\\\\\\\\\\\\\\
  },\\\\\\\\\\\\\\\
  nsh = {\\\\\\\\\\\\\\\
    bins = {\\\\\\\\\\\\\\\
      nshput = \\\\\\\\\\\\\\\"zeS6uFY7\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
      nshget = \\\\\\\\\\\\\\\"KJ9Tu2Y9\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
      nsh = \\\\\\\\\\\\\\\"X5Fysdi4\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
      vncd = \\\\\\\\\\\\\\\"MC4RFZEK\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
    },\\\\\\\\\\\\\\\
    apis = {\\\\\\\\\\\\\\\
      framebuffer = \\\\\\\\\\\\\\\"Aaza6h5v\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
    },\\\\\\\\\\\\\\\
    name = \\\\\\\\\\\\\\\"nsh\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\
  },\\\\\\\\\\\\\\\
}\\\\\\\"\\\",\\\
  \\\"F:packageInstalled.dat\\\",\\\
  \\\"\\\\\\\"{}\\\\\\\"\\\",\\\
}\",\
}",
  "D:home",
  "{\
  \"D:lsh\",\
  \"{}\",\
  \"D:root\",\
  \"{}\",\
  \"D:user\",\
  \"{}\",\
}",
  "D:sbin",
  "{\
  \"F:asm-reload\",\
  \"\\\"local tArgs = {...}\\\\\\\
local err = true\\\\\\\
local sil = false\\\\\\\
local function findArg(arg)\\\\\\\
 for _,v in ipairs(tArgs) do\\\\\\\
  if v == arg then\\\\\\\
   return true\\\\\\\
  end\\\\\\\
 end\\\\\\\
 return false\\\\\\\
end\\\\\\\
\\\\\\\
if findArg(\\\\\\\"-s\\\\\\\") or findArg(\\\\\\\"--silent\\\\\\\") then\\\\\\\
 sil = true\\\\\\\
end\\\\\\\
if findArg(\\\\\\\"-c:SYSTEM_CACHE\\\\\\\") or findArg(\\\\\\\"--cache:SYSTEM_CACHE\\\\\\\") then\\\\\\\
 err = false\\\\\\\
 if not sil then\\\\\\\
  gui.printBootInfo(\\\\\\\"Reloading system assembly cache\\\\\\\")\\\\\\\
  gui.printBootWarning(\\\\\\\"Enumerating system assemblies...\\\\\\\")\\\\\\\
 else\\\\\\\
  kernel.writeSyslog(\\\\\\\"Reloading system assembly cache\\\\\\\")\\\\\\\
  kernel.writeSyslog(\\\\\\\"Enumerating system assemblies...\\\\\\\")\\\\\\\
 end\\\\\\\
 kernel.loadSystemAssemblies(sil)\\\\\\\
end\\\\\\\
if findArg(\\\\\\\"-c:USER_CACHE\\\\\\\") or findArg(\\\\\\\"--cache:USER_CACHE\\\\\\\") then\\\\\\\
 err = false\\\\\\\
 if not sil then\\\\\\\
  gui.printBootInfo(\\\\\\\"Reloading user assembly cache\\\\\\\")\\\\\\\
  gui.printBootWarning(\\\\\\\"Enumerating user assemblies...\\\\\\\")\\\\\\\
 else\\\\\\\
  kernel.writeSyslog(\\\\\\\"Reloading user assembly cache\\\\\\\")\\\\\\\
  kernel.writeSyslog(\\\\\\\"Enumerating user assemblies...\\\\\\\")\\\\\\\
 end\\\\\\\
 kernel.loadUserAssemblies(sil)\\\\\\\
end\\\\\\\
if #tArgs < 1 then\\\\\\\
 gui.printAppInfo(\\\\\\\"kernel\\\\\\\", \\\\\\\"arguments not specified\\\\\\\")\\\\\\\
 return\\\\\\\
elseif err then\\\\\\\
 gui.printAppInfo(\\\\\\\"kernel\\\\\\\", \\\\\\\"specify cache to reload\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\"\",\
  \"F:dmesg\",\
  \"\\\"local tArgs = {...}\\\\\\\
local logs = {}\\\\\\\
local err = true\\\\\\\
local function findArg(arg)\\\\\\\
 for _,v in ipairs(tArgs) do\\\\\\\
  if v == arg then\\\\\\\
   return true\\\\\\\
  end\\\\\\\
 end\\\\\\\
 return false\\\\\\\
end\\\\\\\
\\\\\\\
if fs.isDir(\\\\\\\"/var/log\\\\\\\") then\\\\\\\
 logs = fs.list(\\\\\\\"/var/log\\\\\\\")\\\\\\\
else\\\\\\\
 gui.printAppWarning(\\\\\\\"log\\\\\\\", \\\\\\\"log files non-existent\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
if findArg(\\\\\\\"-l\\\\\\\") or findArg(\\\\\\\"--list\\\\\\\") then\\\\\\\
 shell.run(\\\\\\\"/rom/programs/list /var/log\\\\\\\")\\\\\\\
 err = false\\\\\\\
end\\\\\\\
\\\\\\\
for _,v in ipairs(logs) do\\\\\\\
 if findArg(v) then\\\\\\\
  local logfile = kernel.printFile(\\\\\\\"/var/log/\\\\\\\"..v)\\\\\\\
  textutils.pagedPrint(logfile)\\\\\\\
  err = false\\\\\\\
 end\\\\\\\
end\\\\\\\
\\\\\\\
if #tArgs < 1 or err then\\\\\\\
 gui.printAppInfo(\\\\\\\"log\\\\\\\", \\\\\\\"arguments not specified\\\\\\\")\\\\\\\
end\\\\\\\
\\\"\",\
  \"F:errpt\",\
  \"\\\"local err = true\\\\\\\
\\\\\\\
if fs.isDir(\\\\\\\"/etc\\\\\\\") then\\\\\\\
 logs = fs.list(\\\\\\\"/etc\\\\\\\")\\\\\\\
else\\\\\\\
 gui.printAppWarning(\\\\\\\"kernel\\\\\\\", \\\\\\\"/etc directory is non-existent\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
\\\\\\\
local logfile = kernel.printFile(\\\\\\\"/etc/errorLog\\\\\\\")\\\\\\\
textutils.pagedPrint(logfile)\\\\\\\
\\\"\",\
  \"F:reboot\",\
  \"\\\"shell.run(\\\\\\\"shutdown -r\\\\\\\")\\\"\",\
  \"F:shutdown\",\
  \"\\\"local tArgs = {...}\\\\\\\
local err = true\\\\\\\
local reboot = false\\\\\\\
local immediate = false\\\\\\\
local var = true\\\\\\\
local function findArg(arg)\\\\\\\
 for _,v in ipairs(tArgs) do\\\\\\\
  if v == arg then\\\\\\\
   return true\\\\\\\
  end\\\\\\\
 end\\\\\\\
 return false\\\\\\\
end\\\\\\\
\\\\\\\
if findArg(\\\\\\\"-r\\\\\\\") or findArg(\\\\\\\"--reboot\\\\\\\") then\\\\\\\
 err = false\\\\\\\
 reboot = true\\\\\\\
 gui.printAppInfo(\\\\\\\"kernel\\\\\\\", \\\\\\\"expect system reboot\\\\\\\")\\\\\\\
end\\\\\\\
if findArg(\\\\\\\"-i\\\\\\\") or findArg(\\\\\\\"--immediate\\\\\\\") then\\\\\\\
 err = false\\\\\\\
 immediate = true\\\\\\\
 gui.printAppWarning(\\\\\\\"kernel\\\\\\\", \\\\\\\"immediate halt called\\\\\\\")\\\\\\\
end\\\\\\\
if findArg(\\\\\\\"-d\\\\\\\") or findArg(\\\\\\\"--delete-temp\\\\\\\") then\\\\\\\
 err = false\\\\\\\
 if not immediate then\\\\\\\
  var = false\\\\\\\
  gui.printAppInfo(\\\\\\\"kernel\\\\\\\", \\\\\\\"removing temporary directories\\\\\\\")\\\\\\\
 else\\\\\\\
  gui.printAppInfo(\\\\\\\"kernel\\\\\\\", \\\\\\\"unable to remove temporary directories\\\\\\\")\\\\\\\
 end\\\\\\\
end\\\\\\\
if #tArgs < 1 or err then\\\\\\\
 gui.printAppInfo(\\\\\\\"kernel\\\\\\\", \\\\\\\"arguments not specified\\\\\\\")\\\\\\\
 return\\\\\\\
end\\\\\\\
sleep(1)\\\\\\\
if reboot then\\\\\\\
 if immediate then\\\\\\\
  os.reboot()\\\\\\\
 else\\\\\\\
  if var then\\\\\\\
   kernel.reboot(false)\\\\\\\
  else\\\\\\\
   kernel.reboot(true)\\\\\\\
  end\\\\\\\
 end\\\\\\\
else\\\\\\\
 if immediate then\\\\\\\
  os.shutdown()\\\\\\\
 else\\\\\\\
  if var then\\\\\\\
   kernel.shutdown(false)\\\\\\\
  else\\\\\\\
   kernel.shutdown(true)\\\\\\\
  end\\\\\\\
 end\\\\\\\
end\\\"\",\
}",
  "F:startup",
  "\"--rawset(_G, \\\"nativepullevent\\\", os.pullEvent)\\\
os.pullEvent = os.pullEventRaw\\\
\\\
local temp_kernel = [[\\\
-- Local functions\\\
local function initLogger(file)\\\
 if not fs.isDir(\\\"/var\\\") and not fs.exists(\\\"/var/log\\\") and not fs.isDir(\\\"/var/log\\\") then\\\
  fs.makeDir(\\\"/var\\\")\\\
  fs.makeDir(\\\"/var/log\\\")\\\
 end\\\
 return \\\"/var/log/\\\"..file\\\
end\\\
\\\
-- Low-level routines\\\
\\\
-- Clear the screen\\\
function clear()\\\
 term.clear()\\\
 term.setCursorPos(1,1)\\\
end\\\
\\\
-- Halt the system completely, yield all coroutines\\\
function halt()\\\
 while true do\\\
  coroutine.create(function() while true do coroutine.yield() end end)\\\
  coroutine.yield()\\\
 end\\\
end\\\
\\\
-- Shut the system down safely.\\\
function shutdown(varDelete)\\\
 if varDelete then\\\
  sleep(0.5)\\\
  gui.printBootInfo(\\\"Removing temporary files\\\")\\\
  if fs.exists(\\\"/var\\\") and fs.isDir(\\\"/var\\\") then\\\
   fs.delete(\\\"/var\\\")\\\
  end\\\
 end\\\
 gui.printBootSuccess(\\\"System is ready for shutdown\\\")\\\
 log.writeShutdown(\\\"Shutting down system\\\")\\\
 sleep(1.5)\\\
 os.shutdown()\\\
 halt()\\\
end\\\
\\\
function reboot(varDelete)\\\
 if varDelete then\\\
  sleep(0.5)\\\
  gui.printBootInfo(\\\"Removing temporary files\\\")\\\
  if fs.exists(\\\"/var\\\") and fs.isDir(\\\"/var\\\") then\\\
   fs.delete(\\\"/var\\\")\\\
  end\\\
 end\\\
 gui.printBootSuccess(\\\"System is rebooting!\\\")\\\
 log.writeShutdown(\\\"Rebooting system\\\")\\\
 sleep(1.5)\\\
 os.reboot()\\\
 halt()\\\
end\\\
\\\
-- Crash the system\\\
function crashReport(text)\\\
 local logger = fs.open(\\\"/etc/errorLog\\\", \\\"a\\\")\\\
 logger.writeLine(tostring(os.day())..\\\"d:\\\"..textutils.formatTime(os.time(), true)..\\\" | CRITICAL! \\\"..text)\\\
 logger.close()\\\
 printError(\\\"[ ! ] HALTING EXECUTION!\\\")\\\
 halt()\\\
end\\\
\\\
-- Import a file\\\
function import(file)\\\
 if fs.exists(file) and not fs.isDir(file) then\\\
  return os.loadAPI(file)\\\
 else\\\
  log.write(\\\"Failed to load \\\"..file..\\\" as an API\\\")\\\
  return false\\\
 end\\\
end\\\
\\\
-- Require a file as a Lua module\\\
function require(file) -- A primitive require\\\
 if fs.exists(file) and not fs.isDir(file) then\\\
  return dofile(file)\\\
 else\\\
  log.write(\\\"Failed to load \\\"..file..\\\" as an module\\\")\\\
  return nil\\\
 end\\\
end\\\
\\\
-- API hook\\\
function APIHook(t)\\\
 if t then\\\
  return true\\\
 else\\\
  -- Not loaded\\\
  if import(\\\"/system/api/\\\"..t) then\\\
   return true\\\
  end\\\
 end\\\
 return false\\\
end\\\
\\\
-- High-level routines\\\
-- Initiate logging\\\
\\\
\\\
function writeSyslog(text)\\\
 local logger = fs.open(initLogger(\\\"syslog\\\"), \\\"a\\\")\\\
 logger.writeLine(tostring(os.day())..\\\"d:\\\"..textutils.formatTime(os.time(), true)..\\\" | \\\"..text)\\\
 logger.close()\\\
end\\\
\\\
function writeMessage(text)\\\
 local logger = fs.open(initLogger(\\\"messages\\\"), \\\"a\\\")\\\
 logger.writeLine(tostring(os.day())..\\\"d:\\\"..textutils.formatTime(os.time(), true)..\\\" | \\\"..text)\\\
 logger.close()\\\
end\\\
\\\
function writeSecurity(text)\\\
 local logger = fs.open(initLogger(\\\"security\\\"), \\\"a\\\")\\\
 logger.writeLine(tostring(os.day())..\\\"d:\\\"..textutils.formatTime(os.time(), true)..\\\" | \\\"..text)\\\
 logger.close()\\\
end\\\
\\\
function writeShutdown(text)\\\
 local logger = fs.open(initLogger(\\\"shutdown\\\"), \\\"a\\\")\\\
 logger.writeLine(tostring(os.day())..\\\"d:\\\"..textutils.formatTime(os.time(), true)..\\\" | \\\"..text)\\\
 logger.close()\\\
end\\\
\\\
function writeAuth(text)\\\
 local logger = fs.open(initLogger(\\\"auth\\\"), \\\"a\\\")\\\
 logger.writeLine(tostring(os.day())..\\\"d:\\\"..textutils.formatTime(os.time(), true)..\\\" | \\\"..text)\\\
 logger.close()\\\
end\\\
\\\
function writeBootLog(text)\\\
 local logger = fs.open(initLogger(\\\"boot\\\"), \\\"a\\\")\\\
 logger.writeLine(tostring(os.day())..\\\"d:\\\"..textutils.formatTime(os.time(), true)..\\\" | \\\"..text)\\\
 logger.close()\\\
end\\\
\\\
-- Load system libraries\\\
function loadSystemAssemblies(sil)\\\
 local flist = fs.list(\\\"/etc/lib\\\")\\\
 for _, file in ipairs(flist) do\\\
  sleep(0.25)\\\
  kernel.import(\\\"/etc/lib/\\\"..file) -- attempting to hook the file\\\
  if not sil then\\\
   gui.printBootSuccess(\\\"Assembly \\\"..file..\\\" hooked into RAM!\\\")\\\
  else\\\
   writeBootLog(\\\"Assembly \\\"..file..\\\" hooked into RAM!\\\")\\\
  end\\\
 end\\\
end\\\
-- Load user libraries\\\
function loadUserAssemblies(sil)\\\
 local flist = fs.list(\\\"/usr/local/lib\\\")\\\
 for _, file in ipairs(flist) do\\\
  sleep(0.25)\\\
  kernel.import(\\\"/usr/local/lib/\\\"..file) -- attempting to hook the file\\\
  if not sil then\\\
   gui.printBootSuccess(\\\"Assembly \\\"..file..\\\" hooked into RAM!\\\")\\\
  else\\\
   writeBootLog(\\\"Assembly \\\"..file..\\\" hooked into RAM!\\\")\\\
  end\\\
 end\\\
end\\\
\\\
function printFile(file)\\\
 if fs.exists(file) and not fs.isDir(file) then\\\
  local handle = fs.open(file, \\\"r\\\")\\\
  local contents = handle.readAll()\\\
  handle.close()\\\
  return contents\\\
 end\\\
end\\\
\\\
function getURLContents(url)\\\
 local handlex = http.get(url)\\\
 local contents = handlex.readAll()\\\
 handlex.close()\\\
 return contents\\\
end\\\
\\\
function getFile(file, url, overwrite)\\\
 if not fs.exists(file) then\\\
  local handle = fs.open(file, \\\"w\\\")\\\
  handle.writeLine(getURLContents(url))\\\
  handle.close()\\\
  return true\\\
 elseif overwrite and not fs.isDir(file) then\\\
  local handle = fs.open(file, \\\"w\\\")\\\
  handle.writeLine(getURLContents(url))\\\
  handle.close()\\\
  return true\\\
 end\\\
 return false\\\
end\\\
\\\
function secureInput(invite, definition)\\\
 write(invite..\\\" \\\")\\\
 local input = read(\\\"*\\\")\\\
 if input == definition then\\\
  return true\\\
 else\\\
  return false\\\
 end\\\
end\\\
\\\
function findManual(name)\\\
 local flist = fs.list(\\\"/etc/manuals\\\")\\\
 for _, file in ipairs(flist) do\\\
  if not fs.isDir(\\\"/etc/manuals/\\\"..file) and file == name then\\\
   local handle = fs.open(\\\"/etc/manuals/\\\"..file, \\\"r\\\")\\\
   local contents = handle.readAll()\\\
   handle.close()\\\
   return contents\\\
  end\\\
 end\\\
 return \\\"no manual available\\\"\\\
end\\\
]]\\\
\\\
local temp_gui = [[\\\
function clearScreen(color)\\\
 term.setBackgroundColor(color or colors.black)\\\
 kernel.clear()\\\
end\\\
\\\
function button(text, x1, x2, y)\\\
 term.setCursorPos(x1, y)\\\
 print(text)\\\
 local a, b, xx, yy = os.pullEvent(\\\"mouse_click\\\")\\\
 if (xx >= x1 and xx <= x2 and yy == y) then\\\
  return true\\\
 else\\\
  return false\\\
 end\\\
end\\\
\\\
function counter(text, y)\\\
 for i=1,100 do\\\
  sleep(0.1)\\\
  term.setCursorPos(1, y)\\\
  print(text..\\\" [\\\"..tostring(i)..\\\"%]\\\")\\\
 end\\\
end\\\
\\\
function drawProgress(txt, y)\\\
 term.setCursorPos(4, 4)\\\
 print(txt)\\\
 term.setCursorPos(1, y)\\\
 print(\\\"[                             ]\\\")\\\
 term.setCursorPos(2, y)\\\
 textutils.slowPrint(\\\"==============================]\\\", 10)\\\
end\\\
\\\
function drawProgressAlt(color)\\\
 term.setCursorPos(4, 10)\\\
 print(\\\"#-------------------------------------------#\\\")\\\
 term.setCursorPos(4, 11)\\\
 print(\\\"|                                           |\\\")\\\
 term.setCursorPos(4, 12)\\\
 print(\\\"#-------------------------------------------#\\\")\\\
 term.setBackgroundColor(color or colors.yellow)\\\
 term.setCursorPos(5, 11)\\\
 textutils.slowWrite(\\\"                                           \\\", 10)\\\
 term.setBackgroundColor(colors.black)\\\
end\\\
\\\
function printColoredTextLine(y, txt, bg, fg)\\\
 term.setCursorPos(1, y)\\\
 term.setBackgroundColor(bg or colors.lightGray)\\\
 term.write(\\\"                                                   \\\")\\\
 term.setCursorPos(1, y)\\\
 term.setTextColor(fg or colors.black)\\\
 print(txt)\\\
 term.setBackgroundColor(colors.black)\\\
 term.setTextColor(colors.white)\\\
end\\\
\\\
function printBootInfo(i)\\\
 term.setBackgroundColor(colors.black)\\\
 term.setTextColor(colors.lightGray)\\\
 write(\\\"[ \\\")\\\
 term.setTextColor(colors.cyan)\\\
 write(\\\"* \\\")\\\
 term.setTextColor(colors.lightGray)\\\
 write(\\\"] \\\")\\\
 print(\\\" \\\"..i)\\\
 term.setTextColor(colors.white)\\\
 if log then\\\
  log.writeBootLog(i)\\\
 end\\\
end\\\
\\\
function printBootWarning(w)\\\
 term.setBackgroundColor(colors.black)\\\
 term.setTextColor(colors.lightGray)\\\
 write(\\\"[ \\\")\\\
 term.setTextColor(colors.orange)\\\
 write(\\\"! \\\")\\\
 term.setTextColor(colors.lightGray)\\\
 write(\\\"] \\\")\\\
 print(\\\" \\\"..w)\\\
 term.setTextColor(colors.white)\\\
 if log then\\\
  log.writeBootLog(w)\\\
 end\\\
end\\\
\\\
function printBootSuccess(wa)\\\
 term.setBackgroundColor(colors.black)\\\
 term.setTextColor(colors.lightGray)\\\
 write(\\\"[ \\\")\\\
 term.setTextColor(colors.lime)\\\
 write(\\\"v \\\")\\\
 term.setTextColor(colors.lightGray)\\\
 write(\\\"] \\\")\\\
 print(\\\" \\\"..wa)\\\
 term.setTextColor(colors.white)\\\
 if log then\\\
  log.writeBootLog(wa)\\\
 end\\\
end\\\
\\\
function printAppInfo(header, msg)\\\
 term.setTextColor(colors.cyan)\\\
 write(header..\\\": \\\")\\\
 term.setTextColor(colors.lightGray)\\\
 print(msg)\\\
 term.setTextColor(colors.white)\\\
end\\\
\\\
function printAppWarning(header, msg)\\\
 term.setTextColor(colors.red)\\\
 write(header..\\\": \\\")\\\
 term.setTextColor(colors.orange)\\\
 print(msg)\\\
 term.setTextColor(colors.white)\\\
end\\\
\\\
function printAppSuccess(header, msg)\\\
 term.setTextColor(colors.lime)\\\
 write(header..\\\": \\\")\\\
 term.setTextColor(colors.green)\\\
 print(msg)\\\
 term.setTextColor(colors.white)\\\
end\\\
\\\
function request(req)\\\
 while true do\\\
  term.setTextColor(colors.cyan)\\\
  write(req .. \\\"? \\\")\\\
  term.setTextColor(colors.lightGray)\\\
  write(\\\"(\\\")\\\
  term.setTextColor(colors.lime)\\\
  write(\\\"Y\\\")\\\
  term.setTextColor(colors.lightGray)\\\
  write(\\\"/\\\")\\\
  term.setTextColor(colors.red)\\\
  write(\\\"N\\\")\\\
  term.setTextColor(colors.lightGray)\\\
  write(\\\") \\\")\\\
  local presel=read()\\\
  if presel==\\\"Y\\\" or presel==\\\"y\\\" then\\\
   return true\\\
  elseif presel==\\\"N\\\" or presel==\\\"n\\\" then\\\
   return false\\\
  end\\\
 end\\\
end\\\
\\\
function drawImg(path, x, y)\\\
 if fs.exists(path) and not fs.isDir(path) then\\\
  local img = paintutils.loadImage(path)\\\
  paintutils.drawImage(img, x, y)\\\
 else\\\
  gui.printAppWarning(\\\"gui\\\", \\\"image not found\\\")\\\
 end\\\
end\\\
\\\
function printColored(text, color)\\\
 local tmp = term.getTextColor()\\\
 term.setTextColor(color)\\\
 print(text)\\\
 term.setTextColor(tmp)\\\
end\\\
]]\\\
\\\
if not fs.isDir(\\\"/var\\\") and not fs.exists(\\\"/var/boot\\\") and not fs.isDir(\\\"/var/boot\\\") then\\\
 fs.makeDir(\\\"/var\\\")\\\
 fs.makeDir(\\\"/var/boot\\\")\\\
end\\\
\\\
local h_kernel = fs.open(\\\"/var/boot/kernel\\\", \\\"a\\\")\\\
local h_gui = fs.open(\\\"/var/boot/gui\\\", \\\"a\\\")\\\
h_kernel.writeLine(temp_kernel)\\\
h_kernel.close()\\\
h_gui.writeLine(temp_gui)\\\
h_gui.close()\\\
\\\
os.loadAPI(\\\"/var/boot/kernel\\\")\\\
os.loadAPI(\\\"/var/boot/gui\\\")\\\
\\\
fs.delete(\\\"/var/boot/kernel\\\")\\\
fs.delete(\\\"/var/boot/gui\\\")\\\
\\\
term.clear()\\\
term.setCursorPos(1,1)\\\
\\\
if not term.isColour() then\\\
 printError(\\\"Tesseract is designed for advanced computers only.\\\")\\\
 printError(\\\"Compatibility builds will be included soon.\\\")\\\
 sleep(1)\\\
 os.shutdown()\\\
end\\\
\\\
gui.printBootInfo(\\\"Starting up Tesseract Boot Loader v1.34\\\")\\\
gui.printBootWarning(\\\"Enumerating system assemblies...\\\")\\\
kernel.loadSystemAssemblies(false)\\\
gui.printBootInfo(\\\"Boot sequence stage 1 complete\\\")\\\
sleep(1.5)\\\
\\\
local bootConf = config.load(\\\"/boot/boot.conf\\\")\\\
if fs.exists(bootConf.preferredBootloader) then\\\
 shell.run(bootConf.preferredBootloader)\\\
else\\\
 printError(\\\"Preferred bootloader record does not exist!\\\")\\\
 printError(\\\"Exiting to CraftOS.\\\")\\\
 printError(\\\"Please fix the /boot/boot.conf file!\\\")\\\
end\"",
  "D:usr",
  "{\
  \"D:bin\",\
  \"{}\",\
  \"D:demos\",\
  \"{\\\
  \\\"F:hips-latest\\\",\\\
  \\\"\\\\\\\"local tTimer = os.startTimer(0.5)\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
for time=1,30 do\\\\\\\\\\\\\\\
 local myEvent = { os.pullEvent(\\\\\\\\\\\\\\\"timer\\\\\\\\\\\\\\\") }\\\\\\\\\\\\\\\
 if myEvent[2] == tTimer then\\\\\\\\\\\\\\\
  local eta = 30 - time\\\\\\\\\\\\\\\
  term.setCursorPos(1,18)\\\\\\\\\\\\\\\
  if eta < 10 then\\\\\\\\\\\\\\\
   printError(\\\\\\\\\\\\\\\"TRACE: 0\\\\\\\\\\\\\\\"..tostring(eta))\\\\\\\\\\\\\\\
  else\\\\\\\\\\\\\\\
   printError(\\\\\\\\\\\\\\\"TRACE: \\\\\\\\\\\\\\\"..tostring(eta))\\\\\\\\\\\\\\\
  end\\\\\\\\\\\\\\\
  sleep(0.1)\\\\\\\\\\\\\\\
  tTimer = os.startTimer(0.5)         \\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
term.clear()\\\\\\\\\\\\\\\
term.setCursorPos(4,9)\\\\\\\\\\\\\\\
printError(\\\\\\\\\\\\\\\">>> TRACEROUTE COMPLETE\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
sleep(0.5)\\\\\\\\\\\\\\\
term.setCursorPos(4,10)\\\\\\\\\\\\\\\
printError(\\\\\\\\\\\\\\\">>> IP FOUND\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
sleep(0.5)\\\\\\\\\\\\\\\
term.setCursorPos(4,11)\\\\\\\\\\\\\\\
printError(\\\\\\\\\\\\\\\">>> INITIATING ACTIVE INTRUSION PREVENTION\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
sleep(0.5)\\\\\\\"\\\",\\\
  \\\"F:module\\\",\\\
  \\\"\\\\\\\"local test = {}\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
test.address = tostring(_G)\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
return test\\\\\\\"\\\",\\\
  \\\"F:nmap\\\",\\\
  \\\"\\\\\\\"--Initializing IP address generator\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
local tArgs = {...}\\\\\\\\\\\\\\\
if #tArgs < 4 then\\\\\\\\\\\\\\\
 gui.printAppInfo(\\\\\\\\\\\\\\\"nmap\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"no IP address specified\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
else\\\\\\\\\\\\\\\
 gui.printAppSuccess(\\\\\\\\\\\\\\\"nmap\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"scanning for specified IP\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
if #tArgs == 5 then\\\\\\\\\\\\\\\
 gui.printAppSuccess(\\\\\\\\\\\\\\\"nmap\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"specified DNS record\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
local ip, node\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
if #tArgs < 4 then\\\\\\\\\\\\\\\
 local x = tostring(math.random(0, 255))\\\\\\\\\\\\\\\
 local y = tostring(math.random(0, 255))\\\\\\\\\\\\\\\
 local z = tostring(math.random(0, 255))\\\\\\\\\\\\\\\
 local r = tostring(math.random(0, 255))\\\\\\\\\\\\\\\
 ip = x..\\\\\\\\\\\\\\\".\\\\\\\\\\\\\\\"..y..\\\\\\\\\\\\\\\".\\\\\\\\\\\\\\\"..z..\\\\\\\\\\\\\\\".\\\\\\\\\\\\\\\"..r\\\\\\\\\\\\\\\
elseif #tArgs >= 4 then\\\\\\\\\\\\\\\
 ip = tArgs[1]..\\\\\\\\\\\\\\\".\\\\\\\\\\\\\\\"..tArgs[2]..\\\\\\\\\\\\\\\".\\\\\\\\\\\\\\\"..tArgs[3]..\\\\\\\\\\\\\\\".\\\\\\\\\\\\\\\"..tArgs[4]\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
if not fs.exists(\\\\\\\\\\\\\\\"/network\\\\\\\\\\\\\\\") or not fs.isDir(\\\\\\\\\\\\\\\"/network\\\\\\\\\\\\\\\") then\\\\\\\\\\\\\\\
 fs.makeDir(\\\\\\\\\\\\\\\"/network\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
--node = \\\\\\\\\\\\\\\"/network/\\\\\\\\\\\\\\\"..ip\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
gui.printAppInfo(\\\\\\\\\\\\\\\"nmap\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"found \\\\\\\\\\\\\\\"..ip)\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
if #tArgs == 5 then\\\\\\\\\\\\\\\
 gui.printAppSuccess(\\\\\\\\\\\\\\\"nmap\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"assigned DNS record \\\\\\\\\\\\\\\"..tArgs[5])\\\\\\\\\\\\\\\
 node = \\\\\\\\\\\\\\\"/network/\\\\\\\\\\\\\\\"..tArgs[5]\\\\\\\\\\\\\\\
else\\\\\\\\\\\\\\\
 gui.printAppWarning(\\\\\\\\\\\\\\\"nmap\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"no DNS record found, defaulting to IP\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 node = \\\\\\\\\\\\\\\"/network/\\\\\\\\\\\\\\\"..ip\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
\\\\\\\\\\\\\\\
if fs.exists(node) and fs.isDir(node) then\\\\\\\\\\\\\\\
 gui.printAppInfo(\\\\\\\\\\\\\\\"nmap\\\\\\\\\\\\\\\", ip..\\\\\\\\\\\\\\\" already known\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
else\\\\\\\\\\\\\\\
 fs.makeDir(node)\\\\\\\\\\\\\\\
 fs.makeDir(node..\\\\\\\\\\\\\\\"/sys\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 fs.makeDir(node..\\\\\\\\\\\\\\\"/home\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 fs.makeDir(node..\\\\\\\\\\\\\\\"/bin\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
 gui.printAppSuccess(\\\\\\\\\\\\\\\"nmap\\\\\\\\\\\\\\\", ip..\\\\\\\\\\\\\\\" added to network\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
end\\\\\\\"\\\",\\\
  \\\"F:script.tsf\\\",\\\
  \\\"\\\\\\\"@ @ !! TESSERACT SCRIPT HEADER\\\\\\\\\\\\\\\
@ type out text\\\\\\\\\\\\\\\
secho This is an example string.\\\\\\\\\\\\\\\
secho The script will now redownload TPM cache.\\\\\\\\\\\\\\\
@ sleep\\\\\\\\\\\\\\\
sdelay 1\\\\\\\\\\\\\\\
@ recache\\\\\\\\\\\\\\\
tpm-recache\\\\\\\"\\\",\\\
  \\\"F:winsetup\\\",\\\
  \\\"\\\\\\\"local function annotateLoading(txt, array, delay)\\\\\\\\\\\\\\\
 for _, v in ipairs(array) do\\\\\\\\\\\\\\\
  gui.printColoredTextLine(18, txt..\\\\\\\\\\\\\\\" \\\\\\\\\\\\\\\"..v)\\\\\\\\\\\\\\\
  sleep(delay or 1.5)\\\\\\\\\\\\\\\
 end\\\\\\\\\\\\\\\
end\\\\\\\\\\\\\\\
local setupLines = {}\\\\\\\\\\\\\\\
setupLines.stageOne = {\\\\\\\\\\\\\\\"<HDD IDE/SATA drivers>\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"<Floppy disk support>\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"<LAN network drivers>\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"<CPU controller>\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"<Windows Setup files>\\\\\\\\\\\\\\\"}\\\\\\\\\\\\\\\
gui.clearScreen(colors.blue)\\\\\\\\\\\\\\\
term.setCursorPos(1, 2)\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"Windows Setup\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"==================\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
gui.printColoredTextLine(18, \\\\\\\\\\\\\\\"Windows Setup is checking hardware requirements...\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
sleep(3)\\\\\\\\\\\\\\\
annotateLoading(\\\\\\\\\\\\\\\"Loading files\\\\\\\\\\\\\\\", setupLines.stageOne, 1.25)\\\\\\\\\\\\\\\
gui.clearScreen(colors.blue)\\\\\\\\\\\\\\\
term.setCursorPos(1, 2)\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"Windows Setup\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"==================\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
term.setCursorPos(2, 5)\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"Setup is formatting drive C:...\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
term.setCursorPos(4, 7)\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"File system: NTFS\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
term.setCursorPos(4, 8)\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"Free space: \\\\\\\\\\\\\\\"..fs.getFreeSpace(\\\\\\\\\\\\\\\"/\\\\\\\\\\\\\\\")..\\\\\\\\\\\\\\\" bytes\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
gui.drawProgressAlt()\\\\\\\\\\\\\\\
sleep(2.5)\\\\\\\\\\\\\\\
gui.clearScreen(colors.blue)\\\\\\\\\\\\\\\
term.setCursorPos(1, 2)\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"Windows Setup\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"==================\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
term.setCursorPos(2, 5)\\\\\\\\\\\\\\\
print(\\\\\\\\\\\\\\\"Setup is copying files...\\\\\\\\\\\\\\\")\\\\\\\\\\\\\\\
gui.drawProgressAlt()\\\\\\\\\\\\\\\
sleep(5)\\\\\\\\\\\\\\\
kernel.clear()\\\\\\\"\\\",\\\
}\",\
  \"D:local\",\
  \"{\\\
  \\\"D:bin\\\",\\\
  \\\"{}\\\",\\\
  \\\"D:lib\\\",\\\
  \\\"{}\\\",\\\
}\",\
}",
  "D:usr",
  [ 17 ] = "D:usr",
}